Today Study

SET

  • 집합(Set)는 같은 타입의 서로 다른 값을 중복 없이 저장하고자 할 때 사용하는 집단 자료형이다
  • 집합(Set)은 배열(Array)과 매우 유사하다
  • 순서가 그다지 중요하지 않은 데이터들
  • 중복 없이 한 번만 저장되어야 하는 데이터들
  • 집합을 정의할 때에는 배열 데이터를 사용하여 정의한다
    • 다시 말해, 집합을 정의할 때 값으로 사용되는 데이터 리터럴은 배열과 동일
  • 참고 : 리터럴은 데이터 그 자체를 의미

  • 배열과 동일한 리터럴을 사용하기 때문에 아무런 명시가 없으면 배열로 인식 할 수 있는 여지가 있으므로 꼭 type annotation Set라고 타입을 기재해 주어야 한다

  • 선언, 초기화
let setOfFruitList: Set<String> = ["Apple", "Mango", "Banana"]
let height: Set = [188, 180, 178, 170]
let emptySet = Set<String>()
  • 배열과 집합, Array and Set
let arrayOfFruitList = ["Apple", "Mango", "Banana"]
let arrayHeight = [188, 180, 178, 170]
let emptyArray = [String]()
  • 위의 Set와 비교해보면 어떤것이 배열이고 집합인지 상수명이 없으면 알 수 없다

  • 집합을 선언시 꼭 Set type annotation 해주어야 한다

  • 순서가 없으며, 중복 값이 없는 Set
var listOfNumber: Set = [1, 2, 3]
listOfNumber.insert(1)
listOfNumber
  • Set는 중복 값을 혀용하지 않는다
  • .insert()
    • Summary : Inserts the given element in the set if it it not already present
    • Declaration : mutating func insert(_ newMember: Int) -> (inserted: Bool, memberAfterInsert: Int)
    • Parameters : newMember - An element to insert into the “SET”
    • Returns
      • (true, newMember) : if newMember was not contained in the set.
      • (false, oldMember) : if an element equal to newMember was already contained in the set, the method returns (false, oldMember), where oldMember is the element that was equal to newMember
      • In some cases, oldMember may be distinguishable from newMember by identity comparison or some other means
  • Number of Elements
let listOfFruits: Set<String> = ["Mango","Banana","Apple"]

listOfFruits.count

if !listOfFruits.isEmpty {
    print("\(listOfFruits.count) element(s)")
} else {
    print("empty set")
}
  • Set 안에 들어있는 Elements 들의 개수를 뽑아 내는 방법
    • .count 를 사용
  • .count
    • Summary : The number of elements in the set.
    • Declaration : var count: Int { get }
    • Complexity : O(1).
  • 검색
let listOfName: Set<String> = ["Sua", "Jun", "Soyeon", "Dayoon"]

let giftSet: Set = ["iPhone" , "Shoes", "iMac", "Toy"]

if listOfName.contains("Jun") {
    print("This element is contain in the Set")
} else {
    print("This element is not contain in the Set")
}

let matchTheSet = giftSet.filter { (element) -> Bool in
    return element.hasPrefix("i")
}

matchTheSet
  • .contains()
    • Summary : Returns a Boolean value that indicates whether the given element exists in the set
      • 주어진 element가 set에 들어있는지 확인하고 Boolean 타입으로 value를 return 해 줍니다
    • Declaration : func contains(_ member: String) -> Bool
    • Complexity : O(1)
    • Parameters : member - An element to look for in the set
    • Returns
      • true - if member exists in the set
      • false - otherwise
  • .filter()
    • Summary : returns a new set containing the elements of the set that satisfy the given predicate
    • Declaration : func filter(_ isIncluded: (String) throws -> Bool) rethrows -> Set
    • Parameters : isIncluded - A closure that takes an element as its argument and returns a Boolean value indicating whether the element should be included in the returned set.
    • Returns : A set of the elements that isIncluded allows
  • hasPrefix
    • Declaration : func hasPrefix(_ prefix: String) -> Bool
    • Parameters : prefix
  • 새로운 element 추가
var mutableSet: Set<String> = [] // String 타입만 들어갈 수 있는 빈 Set 생성
mutableSet.insert("Rings")
mutableSet
  • 위에 예시 중 .insert() function을 사용한 예시가 있는데 그 예시에서 받았던 parameter type은 Int 여기서는 String
    • 즉, parameter에 어떤 타입의 element가 들어오느냐에 따라 parameter의 type이 달라진다는 것을 알 수 있다
  • .insert()
    • Summary : Inserts the given element in the set if it it not already present
    • Declaration : mutating func insert(_ newMember: Int) -> (inserted: Bool, memberAfterInsert: Int)
    • Parameters : newMember - An element to insert into the “SET”
    • Returns
      • (true, newMember) : if newMember was not contained in the set.
      • (false, oldMember) : if an element equal to newMember was already contained in the set, the method returns (false, oldMember), where oldMember is the element that was equal to newMember
      • In some cases, oldMember may be distinguishable from newMember by identity comparison or some other means
var result = mutableSet.insert("Necklace")
result
mutableSet
  • 이미 Set에 들어있는 element value를 다시 넣어 보자
result = mutableSet.insert("Necklace")
result
mutableSet
  • 이미 들어있는 element를 .insert function을 이용하여 result set에 넣으려고 시도하였다

  • 그러자 .insert() function에서 output으로 parameter인 inserted에 false로 값이 들어가서 중복되는 값은 Set의 element에 추가 되지 않는다

  • Element의 제거
var exampleRemoveSet: Set<String> = ["Toy", "Rubbish", "Money"] // String 타입의 Element를 받는 Set 생성

if let cleanRubbish = exampleRemoveSet.remove("Rubbish") {
    print("\(cleanRubbish) has been removed!")
}

exampleRemoveSet // 결과값으로 Rubbish element가 지워진 {"Toy","Money"}가 나온다

exampleRemoveSet.removeAll(keepingCapacity: true) // set에 들어있는 모든 elements를 지운다
  • .remove()
    • Summary : Removes the specified element from the set.
    • Declaration : mutating func remove(_ member: String) -> String?
    • Parmeters : member - The element to remove from the set
    • Returns : The value of the member parameter if it was a member of the set, otherwise, nil
  • removeAll()
    • Summary : Removes all members from the set.
    • Declaration : mutating func removeAll(keepingCapacity keepCapacity: Bool = default)
    • Parameters : keepCapacity - if true, the set’s buffer capacity is preserved, the underlying buffer is released. The default is false
    • parameter의 값이 true이면 set의 버퍼 용량은 유지가 됨, 기본 버퍼는 풀려납니다. 기본값은 false
  • 다른 두 Set의 비교
var favoriteSnack: Set<String> = ["오예스", "촉촉한쿠키", "몽쉘"]
var anotherSnack = Set(["새우깡", "치토스", "바나나킥"])
var overlapSnack = Set(["몽쉘", "오예스", "촉촉한쿠키"])

type(of:favoriteSnack)
type(of:anotherSnack)
type(of: overlapSnack)

if favoriteSnack == anotherSnack {
    print("Same favorite snack!!")
} else {
    print("Differnt favorite snack")
}

if favoriteSnack == overlapSnack {
    print("Same favorite snack!!")
} else {
    print("Differnt favorite snack")
}

if favoriteSnack.elementsEqual(anotherSnack) {
    print("Same favorite snack!!")
} else {
    print("Differnt favorite snack")
}

if favoriteSnack.elementsEqual(overlapSnack) {
    print("Same favorite snack!!")
} else {
    print("Differnt favorite snack")
}
  • .elementEqual()
    • Summary : Returns a Boolean value indicating whether this sequence and another sequence contain the same elements in the same order.
  • Declaration
    • func elementsEqual(_ other: OtherSequence) -> Bool where OtherSequence : Sequence, String == OtherSequence.Element
    • At least one of the sequences must be finite
    • Complexity : O(m), where m is the lesser of the length of the sequence and the length of other
    • Parameters : other - A sequence to compare to this sequence
    • Returns : true if this sequence and other contain the same elements in the same order.
let a = Set([1,2,3])
let b = Set([1,3,2])

print(a.elementsEqual(b)) // Prints "false"
print(a.elementsEqual([1, 2, 3])) // Prints "true"
print(a == b) // Prints "true"
  • == 연산자는 순서 없이 같은 elements 가 들어있으면 true를 반환하지만 elementsEqual은 같은 elements가 들어있다고 해도 순서가 다르면 false를 반환한다