English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
Scala Set (ensemble) est un ensemble d'objets sans répétition, tous les éléments sont uniques.
Les collections Scala sont divisées en collections mutables et immuables.
Par défaut, Scala utilise des collections immuables. Si vous souhaitez utiliser des collections mutables, vous devez référencer scala.collection.mutable.Set 。
Par défaut, Scala utilise des collections immuables. Si vous souhaitez utiliser des collections mutables, vous devez faire référence à
val set = Set(1,2,3) println(set.getClass.getName) // println(set.exists(_ %) 2 == 0)) //true println(set.drop(1) //Set(2,3)
Si vous avez besoin d'utiliser des collections mutables, vous devez importer scala.collection.mutable.Set :
import scala.collection.mutable.Set // On peut introduire les collections mutables n'importe où val mutableSet = Set(1,2,3) println(mutableSet.getClass.getName) // scala.collection.mutable.HashSet mutableSet.add(4) mutableSet.remove(1) mutableSet += 5 mutableSet -= 2 println(mutableSet) // Set(5, 3, 4) val another = mutableSet.toSet println(another.getClass.getName) // scala.collection.immutable.Set
Attention :Bien que les Sets variables et invariables aient tous deux des opérations d'ajout ou de suppression d'éléments, il existe une grande différence. Les opérations sur un Set invariable produisent un nouveau Set, et le Set original ne change pas, ce qui est similaire à une List. Cependant, les opérations sur un Set variable changent le Set lui-même, similaire à un ListBuffer.
Les trois opérations de base des ensembles Scala sont :
head retourne le premier élément de l'ensemble
tail retourne un ensemble contenant tous les éléments sauf le premier
isEmpty retourne true lorsque l'ensemble est vide
Toute opération sur un ensemble Scala peut être exprimée à l'aide de ces trois opérations de base. Voici un exemple :
object Test {
def main(args: Array[String]) {
val site = Set("w3codebox", "Google", "Baidu")
val nums: Set[Int] = Set()
println( "Le premier site est : " + site.head )
println( "Le dernier site est : " + site.tail )
println( "Vérifiez si la liste site est vide : " + site.isEmpty )
println( "Vérifiez si nums est vide : " + nums.isEmpty )
}
}Exécuter le code suivant, le résultat est :
$ vim Test.scala $ scala Test.scala Le premier site est : w3codebox Le dernier site est : Set(Google, Baidu) Vérifiez si la liste site est vide : false Vérifiez si nums est vide : true
Vous pouvez utiliser ++ Opérateur ou Set.++() La méthode pour joindre deux ensembles. Si les éléments sont en double, ils seront supprimés. Voici un exemple :
object Test {
def main(args: Array[String]) {
val site1 = Set("w3codebox", "Google", "Baidu")
val site2 = Set("Faceboook", "Taobao")
// ++ Utilisé comme opérateur
var site = site1 ++ site2
println( "site1 ++ site2 : " + site )
// ++ Utilisé comme méthode
site = site1.++(site2)
println( "site1.++(site2) : " + site )
}
}Exécuter le code suivant, le résultat est :
$ vim Test.scala $ scala Test.scala site1 ++ site2 : Set(Faceboook, Taobao, Google, Baidu, w3codebox) site1.++(site2) : Set(Faceboook, Taobao, Google, Baidu, w3codebox)
Vous pouvez utiliser Set.min La méthode pour trouver l'élément le plus petit de l'ensemble, utilisez Set.max La méthode pour trouver l'élément le plus grand de l'ensemble. Voici un exemple :
object Test {
def main(args: Array[String]) {
val num = Set(5,6,9,20,30,45)
// Recherche des éléments les plus grands et les plus petits de l'ensemble
println( "Set(5,6,9,20,30,45) Le plus petit élément de l'ensemble est : " + num.min )
println( "Set(5,6,9,20,30,45) Le plus grand élément de l'ensemble est : " + num.max )
}
}Exécuter le code suivant, le résultat est :
$ vim Test.scala $ scala Test.scala Set(5,6,9,20,30,45) l'élément le plus petit de l'ensemble est : 5 Set(5,6,9,20,30,45) l'élément le plus grand de l'ensemble est : 45
Vous pouvez utiliser Set.& méthode ou Set.intersect méthode pour voir les éléments d'intersection de deux ensembles. Exemple suivant :
object Test {
def main(args: Array[String]) {
val num1 = Set(5,6,9,20,30,45)
val num2 = Set(50,60,9,20,35,55)
// intersection
println( "num1.&(num2) : " + num1.&(num2) )
println( "num1.intersect(num2) : " + num1.intersect(num2) )
}
}Exécuter le code suivant, le résultat est :
$ vim Test.scala $ scala Test.scala num1.&(num2) : Set(20, 9) num1.intersect(num2) : Set(20, 9)
Le tableau suivant liste les méthodes couramment utilisées de Scala Set :
| numéro | méthode et description |
|---|---|
| 1 | def +(elem: A): Set[A] ajouter un nouvel élément x à l'ensemble et créer un nouveau ensemble, à moins que l'élément ne soit déjà présent |
| 2 | def -(elem: A): Set[A] supprimer l'élément de l'ensemble et créer un nouveau ensemble |
| 3 | def contains(elem: A): Boolean retourner true si l'élément existe dans l'ensemble, sinon retourner false. |
| 4 | def &(that: Set[A]): Set[A] retourner l'intersection de deux ensembles |
| 5 | def &~(that: Set[A]): Set[A] retourner la différence de deux ensembles |
| 6 | def +(elem1: A, elem2: A, elems: A*: Set[A] créer un nouvel ensemble immuable en ajoutant les éléments de l'ensemble spécifié |
| 7 | def ++(elems: A): Set[A] fusionner deux ensembles |
| 8 | def -(elem1: A, elem2: A, elems: A*: Set[A] créer un nouvel ensemble immuable en supprimant les éléments de l'ensemble spécifié |
| 9 | def addString(b: StringBuilder): StringBuilder ajouter tous les éléments de l'ensemble immuable à la zone de tampon de chaîne |
| 10 | def addString(b: StringBuilder, sep: String): StringBuilder ajouter tous les éléments de l'ensemble immuable à la zone de tampon de chaîne en utilisant le séparateur spécifié |
| 11 | def apply(elem: A) vérifier si l'ensemble contient l'élément spécifié |
| 12 | def count(p: (A) => Boolean): Int calculer le nombre d'éléments de l'ensemble satisfaisant les conditions spécifiées |
| 13 | def copyToArray(xs: Array[A], start: Int, len: Int): Unit Copier les éléments du jeu immutable dans un tableau |
| 14 | def diff(that: Set[A]): Set[A] Comparer la différence entre deux jeux |
| 15 | def drop(n: Int): Set[A] Retourne un nouveau jeu après avoir ignoré les n premiers éléments |
| 16 | def dropRight(n: Int): Set[A] Retourne un nouveau jeu après avoir ignoré les derniers n éléments |
| 17 | def dropWhile(p: (A) => Boolean): Set[A] Ignorer les éléments de gauche à droite jusqu'à ce que la condition p ne soit plus valable |
| 18 | def equals(that: Any): Boolean La méthode equals peut être utilisée pour toute séquence. Utilisée pour comparer si les séquences sont égales. |
| 19 | def exists(p: (A) => Boolean): Boolean Juger si l'élément qui satisfait la condition spécifiée existe dans le jeu immutable |
| 20 | def filter(p: (A) => Boolean): Set[A] Sortir tous les éléments du jeu immutable qui satisfont la condition spécifiée |
| 21 | def find(p: (A) => Boolean): Option[A] Trouver le premier élément du jeu immutable qui satisfait la condition spécifiée |
| 22 | def forall(p: (A) => Boolean): Boolean Trouver si la condition spécifiée s'applique à tous les éléments du jeu |
| 23 | def foreach(f: (A) => Unit): Unit Appliquer la fonction à tous les éléments du jeu immutable |
| 24 | def head: A Obtenir le premier élément du jeu immutable |
| 25 | def init: Set[A] Retourne tous les éléments, sauf le dernier |
| 26 | def intersect(that: Set[A]): Set[A] Calculer l'intersection de deux jeux |
| 27 | def isEmpty: Boolean Juger si le jeu est vide |
| 28 | def iterator: Iterator[A] Créer un nouvel itérateur pour itérer les éléments |
| 29 | def last: A Retourne le dernier élément |
| 30 | def map[B](f: (A) => B): immutable.Set[B] Recalculer tous les éléments à travers la méthode donnée |
| 31 | def max: A Trouver l'élément le plus grand |
| 32 | def min: A Trouver l'élément le plus petit |
| 33 | def mkString: String Affiche tous les éléments du jeu en tant que chaîne |
| 34 | def mkString(sep: String): String Affiche tous les éléments du jeu en tant que chaîne en utilisant le délimiteur |
| 35 | def product: A Retourne le produit des éléments numériques de l'ensemble immuable |
| 36 | def size: Int Retourne le nombre d'éléments de l'ensemble immuable |
| 37 | def splitAt(n: Int): (Set[A], Set[A]) Décompose l'ensemble immuable en deux conteneurs, le premier composé des n premiers éléments, le second composé des éléments restants |
| 38 | def subsetOf(that: Set[A]): Boolean Retourne true si l'ensemble contient un sous-ensemble, sinon retourne false |
| 39 | def sum: A Retourne la somme de tous les éléments numériques de l'ensemble immuable |
| 40 | def tail: Set[A] Retourne tous les éléments de l'ensemble immuable, sauf le premier élément |
| 41 | def take(n: Int): Set[A] Retourne les n premiers éléments |
| 42 | def takeRight(n: Int): Set[A] Retourne les n derniers éléments |
| 43 | def toArray: Array[A] Convertit un ensemble en tableau |
| 44 | def toBuffer[B >: A]: Buffer[B] Retourne un tampon, contenant tous les éléments de l'ensemble immuable |
| 45 | def toList: List[A] Retourne List, contenant tous les éléments de l'ensemble immuable |
| 46 | def toMap[T, U]: Map[T, U] Retourne Map, contenant tous les éléments de l'ensemble immuable |
| 47 | def toSeq: Seq[A] Retourne Seq, contenant tous les éléments de l'ensemble immuable |
| 48 | def toString(): String Retourne une chaîne, représentée par un objet |
Plus de méthodes peuvent être consultées Documentation de l'API