集合（Set）Swift

Dans ce tutoriel, vous découvrirez les collections, la création de collections, la modification de collections ainsi que certaines opérations courantes sur les collections.

Dans le précédentTableau SwiftDans cet article, nous avons appris à créer des tableaux qui peuvent contenir plusieurs valeurs dans une liste ordonnée.

Mais si nous devons garantir que la liste ne contienne que des valeurs uniques, alors nous utilisons set (collection) en Swift.

Qu'est-ce qu'une collection ?

Une collection n'est qu'un conteneur qui peut stocker plusieurs types de valeurs dans une liste non ordonnée et garantir que les éléments du conteneur sont uniques (c'est-à-dire que chaque valeur ne se produit qu'une seule fois).

Une liste non ordonnée signifie que vous ne pourrez pas obtenir les éléments suivant l'ordre défini pour les éléments de la collection.

Les principaux avantages d'utiliser une collection plutôt qu'un tableau sont que, lorsque vous devez garantir que chaque élément ne se produise qu'une seule fois et que l'ordre des éléments n'est pas important.

Les valeurs stockées dans l'ensemble doivent être hachables. Cela signifie qu'elles doivent fournir une propriété hashValue. Cela est important car les ensembles sont sans ordre, ils utilisent hashValue pour accéder aux éléments de l'ensemble.

Par défaut, tous les types de base de Swift (comme String, Int, Double et Bool) sont hachables et peuvent être utilisés comme types de valeurs pour les ensembles. Cependant, vous pouvez également créer des types hachables que vous pouvez stocker dans un ensemble en Swift.

Comment déclarer un ensemble en Swift ?

Vous pouvez également créer un ensemble vide en spécifiant le type de données comme set, puis en spécifiant le type de données qu'il peut stocker dans <>.

Exemple1Déclaration d'un ensemble vide

let emptyIntSet:Set = []
print(emptyIntSet)

ou

let emptyIntSet:Set = Set()
print(emptyIntSet)

Lors de l'exécution de ce programme, la sortie est :

[　]

Dans le programme ci-dessus, nous avons déclaré une constante de type Set nommée emptyInt , qui peut stocker plusieurs valeurs d'entiers et est initialisée avec la valeur 0.

Comme Swift est un langage de déduction de type, vous pouvez également créer un ensemble de set sans spécifier le type de données, mais vous devez utiliser certaines valeurs pour l'initialiser afin que le compilateur puisse en déduire le type :

Exemple2Déclaration d'un ensemble avec certaines valeurs

let someIntSet:Set = [1,　2,　3,　4,　5,　6,　7,　8,　9]
print(someIntSet)

Lors de l'exécution de ce programme, la sortie est :

[2,　4,　9,　5,　6,　7,　3,　1,　8]

Dans le programme ci-dessus, nous avons déclaré une constante someIntSet qui peut stocker un ensemble d'Integer sans spécifier explicitement le type. Cependant, nous devons ajouter :Set lors de la définition de la variable, sinon Swift créera pour nous un tableau.

En plus de cela, en tant qu'array, nous utilisons des crochets [] pour 1、2、3、4、5、6、7、8、9 Les valeurs initialisent l'ensemble.

Vous savez déjà que lorsque vous essayez d'utiliser print(someIntSet) pour imprimer les valeurs de l'ensemble, vous obtiendrez une séquence différente, différente de l'ordre des éléments que vous avez définis dans l'ensemble, car il n'y a pas d'ordre défini pour le stockage des valeurs. Par conséquent, l'ordre d'accès change à chaque fois.

Exemple3Déclaration d'un ensemble avec des valeurs répétées

let someStrSet:Set = ["ab","bc","cd","de","ab"]
print(someStrSet)

Lors de l'exécution de ce programme, la sortie est :

["de", "ab", "cd", "bc"]

Vous savez déjà que lorsque vous essayez d'imprimer les valeurs de l'ensemble en tant que print(someIntSet) , dans le programme ci-dessus, nous avons défini une valeur répétée ab dans l'ensemble. De plus. Lorsque nous essayons d'accéder aux valeurs de l'ensemble en utilisant print(someStrSet) , les valeurs répétées sont automatiquement supprimées de l'ensemble. Par conséquent, set garantit que ses éléments sont uniques/Valeurs.

Vous pouvez également déclarer une collection avec votre propre type personnalisé Hashable en Swift.

Comment accéder aux éléments de set en Swift ?

Ne pas utiliser la syntaxe d'index pour accéder aux éléments de la collection. Cela est dû au fait que les collections sont non ordonnées et n'ont pas d'index d'accès aux éléments.
Ainsi, vous devez utiliser ses méthodes et attributs ou utiliser for-Un boucle in pour accéder aux éléments.

Exemple4：Accès aux éléments de la collection avec for...in

var someStrSet:Set = ["ab", "bc", "cd", "de"]
for val in someStrSet {
　　　　print(val)
}

Lors de l'exécution de ce programme, la sortie est :

de
ab
cd
bc

Dans le programme ci-dessus, la valeur obtenue est différente de l'ordre des éléments de la collection, car les collections sont non ordonnées, contrairement aux tableaux.

Vous pouvez également accéder aux éléments de la collection, supprimer directement les valeurs de la collection, comme suit :

Exemple5：Accéder aux éléments de la collection avec remove()

var someStrSet:Set = ["ab", "bc", "cd", "de"]
let someVal = someStrSet.remove("cd")
print(someVal)
print(someStrSet)

Lors de l'exécution de ce programme, la sortie est :

Optional("cd")
["de", "ab", "bc"]

Dans le programme ci-dessus, vous pouvez voir que la méthode remove retourne une chaîne optionnelle. Par conséquent, il est recommandé d'effectuer le traitement optionnel suivant. Pour en savoir plus sur les optionnels, veuillez visiterOptionnel Swift.

Exemple6：Traitement optionnel de remove()

var someStrSet:Set = ["ab", "bc", "cd", "de"]
if let someVal = someStrSet.remove("cd") {
　　　　print(someVal)
　　　　print(someStrSet)
} else {
　　　　print("cannot find element to remove")
}

Lors de l'exécution de ce programme, la sortie est :

cd
["de", "ab", "bc"]

Comment ajouter de nouveaux éléments dans une collection ?

Vous pouvez utiliser la méthode insert() de Swift pour ajouter de nouveaux éléments à une collection.

Exemple7：Ajouter de nouveaux éléments avec insert()

var someStrSet:Set = ["ab", "bc", "cd", "de"]
someStrSet.insert("ef")
print(someStrSet)

Lors de l'exécution de ce programme, la sortie est :

["ab", "de", "cd", "ef", "bc"]

Dans le programme ci-dessus, nous utilisons la méthode insert() de la collection pour ajouter de nouveaux éléments à la collection. Comme les collections sont non ordonnées, la position d'insertion de l'élément est inconnue.

Opérations sur les collections

L'un des principaux avantages de l'utilisation de collections est la capacité d'exécuter des opérations sur les collections, telles que combiner deux collections, déterminer quels éléments communs elles ont, etc. Ces opérations sont similaires aux opérations de collections en mathématiques.

1.并集

两个集合a和b的并集是在a或b中 或 在a和b两者中的元素的集合。

let a: Set = [1,　3,　5,　7,　9]
let b: Set = [0,　2,　4,　6,　8]
print(a.union(b))

当您运行上述程序时，输出将是：

[8,　2,　9,　4,　5,　7,　6,　3,　1, 0]

2.交集

两个集合a和b的交集是包含a的所有元素的集合，这些元素同时也属于b。

let a: Set = [1,　3,　5,　7,　9]
let b: Set = [0,　3,　7,　6,　8]
print(a.intersection(b))

当您运行上述程序时，输出将是：

[7,　3]

因此，print(a.intersection(b))输出一个新的集合，其值 [7、3] 在 a 和 b 集合中都存在。

3.差集

两个集合a和b的差集，它包含 a 的所有元素，但去掉同样属于 b 的元素。

let a: Set = [1,　3,　5,　7,　9]
let b: Set = [0,　3,　7,　6,　8]
print(a.subtracting(b))

当您运行上述程序时，输出将是：

[5,　9,　1]

因此，print(a.subtracting(b)) 输出具有值[ 5，9，1] 的新集合。

4.对称差集

两个集合a和b的对称差是包含所有元素的集合，这些元素位于两个集合中的任何一个中，但不同时存在于两个集合中。

let a: Set = [1,　3,　5,　7,　9]
let b: Set = [0,　3,　7,　6,　8]
print(a.symmetricDifference(b))

当您运行上述程序时，输出将是：

[5,　6,　8, 0,　1,　9]

因此，print(a.symmetricDifference(b)) 输出具有值[ 5、6、8、0、1、9] 的新集合。

集合成员关系和相等运算

集合相等

您可以使用 == 运算符检查两个集合是否包含相同的元素。如果两个集合包含相同的元素，则返回true，否则返回false。

Exemple5：集合相等操作

let a: Set = [1,　3,　5,　7,　9]
let b: Set = [0,　3,　7,　6,　8]
let c:Set = [9,　7,　3,　1,　5]
if a == b {
　　　　print("a和b相同")
} else {
　　　　print("a和b不同")
}
if a == c {
　　　　print("a和c相同")
} else {
　　　　print("a和c不同")
}

当您运行上述程序时，输出将是：

a和b不同
a和c相同

集合成员关系

您还可以使用以下方法检查两个集合之间的关系：

• isSubset(of:) - 此方法确定一个集合的所有值是否都存在于指定的集合中。
  

• isSuperset(of:)　 - 此方法确定集合是否包含指定集合中的所有值。

• isStrictSubset(of:) ou isStrictSuperset(of:) - 此方法确定一个集合是指定集合的子集还是超集，但不等于指定集合。

• isDisjoint(with:)　 - 此方法确定两个集合是否没有共同的值。

Exemple6：集合成员关系操作

let a: Set = [1,　3,　5,　7,　9]
let b: Set = [0,　3,　1,　7,　6,　8,　9,　5]
print("isSubset:", a.isSubset(of: b))
print("isSuperset:", b.isSuperset(of: a))
print("isStrictSubset:", a.isStrictSubset(of: b))
print("isDisjointWith:", a.isDisjoint(with: b))

当您运行上述程序时，输出将是：

isSubset: true
isSuperset: true
isStrictSubset: true
isDisjointWith: false

让我们分析下面的print语句中使用的方法：

• isSubset返回 true，因为集合b包含a中的所有元素

• isSuperset返回true，因为b包含a的所有值。

• isStrictSubset返回true，因为集合b包含a中的所有元素，并且两个集合不相等。

• isDisjointWithreturns 返回 false，因为a和b具有一些共同的值。

集合内置函数和属性

1. isEmpty 属性

此属性确定集合是否为空。如果集合不包含任何值，它返回true，否则返回false。

Exemple7：isEmpty如何工作？

let intSet:Set = [21,　34,　54,　12]
print(intSet.isEmpty)

Lors de l'exécution de ce programme, la sortie est :

false

2.first 属性

此属性用于访问集合的第一个元素。

Exemple8：first如何工作？

let intSet = [21,　34,　54,　12]
print(intSet.first)

Lors de l'exécution de ce programme, la sortie est :

Optional(54)

由于Set是无序集合，因此 first 属性并不能保证是该集合的第一个元素。 您很有可能会得到54以外的其他值。

同样，您可以使用 last 属性来访问集合的最后一个元素。

3.insert 函数 - 插入元素

insert函数用于在集合中插入/追加元素。

Exemple9：insert函数如何工作？

var intSet:Set = [21,　34,　54,　12]
intSet.insert(50)
print(intSet)

Lors de l'exécution de ce programme, la sortie est :

[54,　12,　50,　21,　34]

4.reversed() - 反转集合

此函数以相反的顺序返回集合的元素。

Exemple10：reversed()如何工作？

var intSet:Set = [21,　22,　23,　24,　25]
print(intSet)
let reversedSet = intSet.reversed()
print(reversedSet)

Lors de l'exécution de ce programme, la sortie est :

[22,　23,　21,　24,　25]
[25,　24,　21,　23,　22]

5.count - Retourne le nombre total d'éléments du jeu de données

Cette propriété retourne le nombre total d'éléments dans le jeu de données.

Exemple11：comment fonctionne le comptage count ?

let floatSet:Set = [10.2,　21.3,　32.0,　41.3]
print(floatSet.count)

Lors de l'exécution de ce programme, la sortie est :

4

6removeFirst - Supprimer et retourner la première valeur du jeu de données

Cette fonction supprime et retourne la première valeur du jeu de données.

Exemple12：comment fonctionne removeFirst ?

var strSet:Set = ["ab", "bc", "cd", "de"]
let removedVal = strSet.removeFirst()
print("la valeur supprimée est \(removedVal)")
print(strSet)

Lors de l'exécution de ce programme, la sortie est :

la valeur supprimée est de
["ab", "cd", "bc"]

De même, vous pouvez également utiliser la fonction removeAll pour vider le jeu de données.