Collection Types

image

swift에서 collection들은 타입을 지정하고 그 타입의 것들만 받아들이게 된다.

NOTE

Swift’s array, set, and dictionary types are implemented as generic collections. For more on generic types and collections, see Generics.

Mutability of Collections

If you create an array, a set, or a dictionary, and assign it to a variable, the collection that is created will be mutable. This means that you can change (or mutate) the collection after it’s created by adding, removing, or changing items in the collection. If you assign an array, a set, or a dictionary to a constant, that collection is immutable, and its size and contents cannot be changed.

Arrays

Array Type Shorthand Syntax

만드는법

  • Array<Element>, where Element is the type of values the array is allowed to store. 
  • [Element]

Creating an Empty Array

var someInts = [Int]()
print(“someInts is of type [Int] with (someInts.count) items.”)
// Prints “someInts is of type [Int] with 0 items.”

Alternatively, if the context already provides type information, such as a function argument or an already typed variable or constant, you can create an empty array with an empty array literal, which is written as [] (an empty pair of square brackets):

someInts.append(3)
// someInts now contains 1 value of type Int
someInts = []
// someInts is now an empty array, but is still of type [Int]

Creating an Array with a Default Value

 creating an array of a certain size with all of its values set to the same default value. 

var threeDoubles = Array(repeating: 0.0, count: 3)
// threeDoubles is of type [Double], and equals [0.0, 0.0, 0.0]

Creating an Array by Adding Two Arrays Together

var anotherThreeDoubles = Array(repeating: 2.5, count: 3)
// anotherThreeDoubles is of type [Double], and equals [2.5, 2.5, 2.5]
var sixDoubles = threeDoubles + anotherThreeDoubles
// sixDoubles is inferred as [Double], and equals [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]

Creating an Array with an Array Literal

[value 1, value 2, value 3]

var shoppingList: [String] = [“Eggs”, “Milk”]
// shoppingList has been initialized with two initial items

Thanks to Swift’s type inference, you don’t have to write the type of the array if you’re initializing it with an array literal containing values of the same type. The initialization of shoppingList could have been written in a shorter form instead:

var shoppingList = [“Eggs”, “Milk”]

Accessing and Modifying an Array

You access and modify an array through its methods and properties, or by using subscript syntax.

print(“The shopping list contains (shoppingList.count) items.”)
// Prints “The shopping list contains 2 items.”

if shoppingList.isEmpty {
   print(“The shopping list is empty.”)
} else {
   print(“The shopping list is not empty.”)
}
// Prints “The shopping list is not empty.”

shoppingList.append(“Flour”)
// shoppingList now contains 3 items, and someone is making pancakes

Alternatively

shoppingList += [“Baking Powder”]
// shoppingList now contains 4 items
shoppingList += [“Chocolate Spread”, “Cheese”, “Butter”]
// shoppingList now contains 7 items

Retrieve a value from the array by using subscript syntax, passing the index of the value you want to retrieve within square brackets immediately after the name of the array:

var firstItem = shoppingList[0]
// firstItem is equal to “Eggs”

NOTE

Arrays in Swift are always zero-indexed.

subscript syntax to change an existing value at a given index:

shoppingList[0] = “Six eggs”
// the first item in the list is now equal to “Six eggs” rather than “Eggs”

You can also use subscript syntax to change a range of values at once, even if the replacement set of values has a different length than the range you are replacing. The following example replaces "Chocolate Spread", "Cheese", and "Butter" with "Bananas" and "Apples":

shoppingList[4…6] = [“Bananas”, “Apples”]
// shoppingList now contains 6 items

insert(_:at:) method:

shoppingList.insert(“Maple Syrup”, at: 0)
// shoppingList now contains 7 items
// “Maple Syrup” is now the first item in the list

This call to the insert(_:at:) method inserts a new item with a value of "Maple Syrup" at the very beginning of the shopping list, indicated by an index of 0.

remove(at:) method

let mapleSyrup = shoppingList.remove(at: 0)
// the item that was at index 0 has just been removed
// shoppingList now contains 6 items, and no Maple Syrup
// the mapleSyrup constant is now equal to the removed “Maple Syrup” string

NOTE

If you try to access or modify a value for an index that is outside of an array’s existing bounds, you will trigger a runtime error. You can check that an index is valid before using it by comparing it to the array’s countproperty. The largest valid index in an array is count - 1 because arrays are indexed from zero—however, when count is 0 (meaning the array is empty), there are no valid indexes.

removeLast() method 

let apples = shoppingList.removeLast()
// the last item in the array has just been removed
// shoppingList now contains 5 items, and no apples
// the apples constant is now equal to the removed “Apples” string

Iterating Over an Array

for item in shoppingList {
   print(item)
}
// Six eggs
// Milk
// Flour
// Baking Powder
// Bananas

If you need the integer index of each item as well as its value, use the enumerated() method to iterate over the array instead. For each item in the array, the enumerated() method returns a tuple composed of an integer and the item. The integers start at zero and count up by one for each item; if you enumerate over a whole array, these integers match the items’ indices. You can decompose the tuple into temporary constants or variables as part of the iteration:

for (index, value) in shoppingList.enumerated() {
   print(“Item (index + 1): (value)”)
}
// Item 1: Six eggs
// Item 2: Milk
// Item 3: Flour
// Item 4: Baking Powder
// Item 5: Bananas

Sets

A set stores distinct values of the same type in a collection with no defined ordering.

NOTE

Swift’s Set type is bridged to Foundation’s NSSet class.

Hash Values for Set Types

A type must be hashable in order to be stored in a set—that is, the type must provide a way to compute a hash value for itself. A hash value is an Int value that is the same for all objects that compare equally, such that if a == b, it follows that a.hashValue == b.hashValue.

All of Swift’s basic types (such as String, Int, Double, and Bool) are hashable by default, and can be used as set value types or dictionary key types. Enumeration case values without associated values (as described in Enumerations) are also hashable by default.

NOTE

You can use your own custom types as set value types or dictionary key types by making them conform to the Hashable protocol from Swift’s standard library. Types that conform to the Hashable protocol must provide a gettable Int property called hashValue. The value returned by a type’s hashValue property is not required to be the same across different executions of the same program, or in different programs.

Because the Hashable protocol conforms to Equatable, conforming types must also provide an implementation of the equals operator (==). The Equatable protocol requires any conforming implementation of == to be an equivalence relation. That is, an implementation of == must satisfy the following three conditions, for all values a, b, and c:

  • a == a (Reflexivity)
  • a == b implies b == a (Symmetry)
  • a == b && b == c implies a == c (Transitivity)

Set Type Syntax

The type of a Swift set is written as Set<Element>, where Element is the type that the set is allowed to store. Unlike arrays, sets do not have an equivalent shorthand form.

Creating and Initializing an Empty Set

var letters = Set<Character>()
print(“letters is of type Set<Character> with (letters.count) items.”)
// Prints “letters is of type Set<Character> with 0 items.”

NOTE

The type of the letters variable is inferred to be Set<Character>, from the type of the initializer.

Alternatively, if the context already provides type information, such as a function argument or an already typed variable or constant, you can create an empty set with an empty array literal:

letters.insert(“a”)
// letters now contains 1 value of type Character
letters = []
// letters is now an empty set, but is still of type Set<Character> 위에서 이미 character라고 정해졌기 때문에 여기서 또 명시할필요는 없다.

Creating a Set with an Array Literal

var favoriteGenres: Set<String> = [“Rock”, “Classical”, “Hip hop”]
// favoriteGenres has been initialized with three initial items

The favoriteGenres variable is declared as “a set of String values”, written as Set<String>. Because this particular set has specified a value type of String.

A set type cannot be inferred from an array literal alone, so the type Set must be explicitly declared. However, because of Swift’s type inference, you don’t have to write the type of the set if you’re initializing it with an array literal containing values of the same type. (데이터타입은 명시하지 않아도 되지만  set이라고는 명시해야 된다.)

var favoriteGenres: Set = [“Rock”, “Classical”, “Hip hop”]

Accessing and Modifying a Set

You access and modify a set through its methods and properties.

count property:

print(“I have (favoriteGenres.count) favorite music genres.”)
// Prints “I have 3 favorite music genres.”

isEmpty property

if favoriteGenres.isEmpty {
   print(“As far as music goes, I’m not picky.”)
} else {
   print(“I have particular music preferences.”)
}
// Prints “I have particular music preferences.”

insert(_:) method:

favoriteGenres.insert(“Jazz”)
// favoriteGenres now contains 4 items

remove(_:) method, which removes the item if it’s a member of the set, and returns the removed value, or returns nil if the set did not contain it. 

all items in a set can be removed with its removeAll() method.

if let removedGenre = favoriteGenres.remove(“Rock”) {
   print(“(removedGenre)? I’m over it.”)
} else {
   print(“I never much cared for that.”)
}
// Prints “Rock? I’m over it.”

contains(_:) method.

if favoriteGenres.contains(“Funk”) {
   print(“I get up on the good foot.”)
} else {
   print(“It’s too funky in here.”)
}
// Prints “It’s too funky in here.”

Iterating Over a Set

for genre in favoriteGenres {
   print(“(genre)”)
}
// Jazz
// Hip hop
// Classical

Swift’s Set type does not have a defined ordering. To iterate over the values of a set in a specific order, use the sorted() method, which returns the set’s elements as an array sorted using the < operator.

for genre in favoriteGenres.sorted() {
   print(“(genre)”)
}
// Classical
// Hip hop
// Jazz

Performing Set Operations

Fundamental Set Operations

image
  • Use the intersection(_:) method to create a new set with only the values common to both sets.
  • Use the symmetricDifference(_:) method to create a new set with values in either set, but not both.
  • Use the union(_:) method to create a new set with all of the values in both sets.
  • Use the subtracting(_:) method to create a new set with values not in the specified set.

let oddDigits: Set = [1, 3, 5, 7, 9]
let evenDigits: Set = [0, 2, 4, 6, 8]
let singleDigitPrimeNumbers: Set = [2, 3, 5, 7]
oddDigits.union(evenDigits).sorted()
// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
oddDigits.intersection(evenDigits).sorted()
// []
oddDigits.subtracting(singleDigitPrimeNumbers).sorted()
// [1, 9]
oddDigits.symmetricDifference(singleDigitPrimeNumbers).sorted()
// [1, 2, 9]

Set Membership and Equality

Set a is a superset of set b, because a contains all elements in b. Conversely, set b is a subset of set a.

image

Use the “is equal” operator (==) to determine whether two sets contain all of the same values.

Use the isSubset(of:) method to determine whether all of the values of a set are contained in the specified set.

Use the isSuperset(of:) method to determine whether a set contains all of the values in a specified set.

Use the isStrictSubset(of:) or isStrictSuperset(of:) methods to determine whether a set is a subset or superset, but not equal to, a specified set.

Use the isDisjoint(with:) method to determine whether two sets have no values in common.

let houseAnimals: Set = [“🐶”, “🐱”]
let farmAnimals: Set = [“🐮”, “🐔”, “🐑”, “🐶”, “🐱”]
let cityAnimals: Set = [“🐦”, “🐭”]
houseAnimals.isSubset(of: farmAnimals)
// true
farmAnimals.isSuperset(of: houseAnimals)
// true
farmAnimals.isDisjoint(with: cityAnimals)
// true

Dictionaries

A dictionary stores associations between keys of the same type and values of the same type in a collection with no defined ordering. Each value is associated with a unique key.

NOTE

Swift’s Dictionary type is bridged to Foundation’s NSDictionary class.

Dictionary Type Shorthand Syntax

Dictionary<Key, Value>

NOTE

A dictionary Key type must conform to the Hashable protocol, like a set’s value type.

You can also write the type of a dictionary in shorthand form as [Key: Value].

Creating an Empty Dictionary

var namesOfIntegers = [Int: String]()
// namesOfIntegers is an empty [Int: String] dictionary

If the context already provides type information, you can create an empty dictionary with an empty dictionary literal, which is written as [:] (a colon inside a pair of square brackets):

namesOfIntegers[16] = “sixteen”
// namesOfIntegers now contains 1 key-value pair
namesOfIntegers = [:]
// namesOfIntegers is once again an empty dictionary of type [Int: String]

Accessing and Modifying a Dictionary

You access and modify a dictionary through its methods and properties, or by using subscript syntax.

read-only count property:

print(“The airports dictionary contains (airports.count) items.”)
// Prints “The airports dictionary contains 2 items.”

isEmpty property

if airports.isEmpty {
   print(“The airports dictionary is empty.”)
} else {
   print(“The airports dictionary is not empty.”)
}
// Prints “The airports dictionary is not empty.”

assign a new value

airports[“LHR”] = “London”
// the airports dictionary now contains 3 items

change the value

airports[“LHR”] = “London Heathrow”
// the value for “LHR” has been changed to “London Heathrow”

updateValue(_:forKey:) method to set or update the value for a particular key. updateValue(_:forKey:) method sets a value for a key if none exists, or updates the value if that key already exists. Unlike a subscript, however, the updateValue(_:forKey:) method returns the old value after performing an update.

The updateValue(_:forKey:) method returns an optional value of the dictionary’s value type. For a dictionary that stores String values, for example, the method returns a value of type String?, or “optional String”. This optional value contains the old value for that key if one existed before the update, or nil if no value existed:

if let oldValue = airports.updateValue(“Dublin Airport”, forKey: “DUB”) {
   print(“The old value for DUB was (oldValue).”)
}
// Prints “The old value for DUB was Dublin.”

if let airportName = airports[“DUB”] {
   print(“The name of the airport is (airportName).”)
} else {
   print(“That airport is not in the airports dictionary.”)
}
// Prints “The name of the airport is Dublin Airport.”

remove a key-value pair from a dictionary by assigning a value of nil for that key:

airports[“APL”] = “Apple International”
// “Apple International” is not the real airport for APL, so delete it

airports[“APL”] = nil
// APL has now been removed from the dictionary

Alternatively, remove a key-value pair from a dictionary with the removeValue(forKey:) method. This method removes the key-value pair if it exists and returns the removed value, or returns nil if no value existed:

if let removedValue = airports.removeValue(forKey: “DUB”) {
   print(“The removed airport’s name is (removedValue).”)
} else {
   print(“The airports dictionary does not contain a value for DUB.”)
}
// Prints “The removed airport’s name is Dublin Airport.”

Iterating Over a Dictionary

You can iterate over the key-value pairs in a dictionary with a forin loop. Each item in the dictionary is returned as a (key, value) tuple, and you can decompose the tuple’s members into temporary constants or variables as part of the iteration:

for (airportCode, airportName) in airports {
   print(“(airportCode): (airportName)”)
}
// YYZ: Toronto Pearson
// LHR: London Heathrow

keys and values properties:

for airportCode in airports.keys {
   print(“Airport code: (airportCode)”)
}
// Airport code: YYZ
// Airport code: LHR
for airportName in airports.values {
   print(“Airport name: (airportName)”)
}
// Airport name: Toronto Pearson
// Airport name: London Heathrow

let airportCodes = [String](airports.keys)
// airportCodes is [“YYZ”, “LHR”]

let airportNames = [String](airports.values)
// airportNames is [“Toronto Pearson”, “London Heathrow”]

Swift’s Dictionary type does not have a defined ordering. To iterate over the keys or values of a dictionary in a specific order, use the sorted() method on its keys or values property.

Convert Set of String to Array of String in Java – Techie Delight

Generic Set in Java

How to change apache2 default charset in Ubuntu | Ubuntu Geek

utf 8 – PHP: Convert any string to UTF-8 without knowing the original character set, or at least try – Stack Overflow