Scala Set (Collection)

Scala 集合Collections Scala

Scala Set est une collection d'objets sans doublons ; 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érencerscala.collection.mutable.Setle package.

Par défaut, scala.collection.immutable.Set est référencé. Un exemple de collection immuable est le suivant :

Exemple

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 devez utiliser des collections mutables, vous devez importer scala.collection.mutable.Set :

Exemple

import scala.collection.mutable.Set // On peut importer une collection mutable 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

Remarque :Bien que Set mutable et Set immuable aient tous deux des opérations pour ajouter ou supprimer des éléments, il y a une très grande différence. Opérer sur un Set immuable produit un nouvel ensemble, et l'ensemble d'origine reste inchangé, tout comme List. Opérer sur un Set mutable, en revanche, modifie le Set lui-même, comme ListBuffer.

Opérations de base sur Set

Les collections Scala ont trois opérations de base :

  • headRenvoie le premier élément de la collection
  • tailRenvoie une collection contenant tous les éléments sauf le premier
  • isEmptyRenvoie true lorsque la collection est vide

Toute opération sur les collections Scala peut être exprimée à l'aide de ces trois opérations de base. Exemple :

Exemple

object Test {
   def main(args: Array[String]) {
      val site = Set("Example", "Google", "Baidu")
      val nums: Set[Int] = Set()

      println( "Le premier site Web est : " + site.head )
      println( "Le dernier site web est : " + site.tail )
      println( "Vérifier si la liste site est vide : " + site.isEmpty )
      println( "Vérifier si nums est vide : " + nums.isEmpty )
   }
}

L'exécution du code ci-dessus produit la sortie suivante :

$ vim Test.scala 
$ scala Test.scala 
第一网站是 : Example
最后一个网站是 : Set(Google, Baidu)
查看列表 site 是否为空 : false
查看 nums 是否为空 : true

Concaténation d'ensembles

Vous pouvez utiliser++l'opérateur ouSet.++()méthode pour concaténer deux ensembles. S'il y a des éléments en double, ils seront supprimés. Exemple :

Exemple

object Test {
   def main(args: Array[String]) {
      val site1 = Set("Example", "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 )
   }
}

L'exécution du code ci-dessus produit la sortie suivante :

$ vim Test.scala 
$ scala Test.scala 
site1 ++ site2 : Set(Faceboook, Taobao, Google, Baidu, Example)
site1.++(site2) : Set(Faceboook, Taobao, Google, Baidu, Example)

Recherche des éléments les plus grands et les plus petits dans un ensemble

Vous pouvez utiliserSet.minméthode pour trouver le plus petit élément dans l'ensemble, utilisezSet.maxméthode pour trouver le plus grand élément dans l'ensemble. Exemple :

Exemple

object Test {
   def main(args: Array[String]) {
      val num = Set(5,6,9,20,30,45)

      // Trouver les éléments les plus grands et les plus petits dans l'ensemble
      println( "L'élément minimum dans Set(5,6,9,20,30,45) est : " + num.min )
      println( "L'élément maximum dans Set(5,6,9,20,30,45) est : " + num.max )
   }
}

L'exécution du code ci-dessus produit la sortie suivante :

$ vim Test.scala 
$ scala Test.scala 
Set(5,6,9,20,30,45) 集合中的最小元素是 : 5
Set(5,6,9,20,30,45) 集合中的最大元素是 : 45

Intersection

Vous pouvez utiliserSet.&méthode ouSet.intersectméthode pour afficher les éléments d'intersection des deux ensembles. Exemple :

Exemple

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) )
   }
}

L'exécution du code ci-dessus produit la sortie suivante :

$ vim Test.scala 
$ scala Test.scala 
num1.&(num2) : Set(20, 9)
num1.intersect(num2) : Set(20, 9)

Méthodes courantes de Scala Set

Le tableau suivant répertorie les méthodes couramment utilisées de Scala Set :

Non. Méthode et description
1

def +(elem: A): Set[A]

Ajoute un nouvel élément x à l'ensemble et crée un nouvel ensemble, sauf si l'élément existe déjà
2

def -(elem: A): Set[A]

Supprime des éléments de l'ensemble et crée un nouvel ensemble
3

def contains(elem: A): Boolean

Renvoie true si l'élément existe dans l'ensemble, sinon false.
4

def &(that: Set[A]): Set[A]

Renvoie l'intersection de deux ensembles
5

def &~(that: Set[A]): Set[A]

Renvoie la différence de deux ensembles
6

def +(elem1: A, elem2: A, elems: A*): Set[A]

Crée une nouvelle collection immuable en ajoutant des éléments provenant de la collection spécifiée
7

def ++(elems: A): Set[A]

Fusionne deux collections
8

def -(elem1: A, elem2: A, elems: A*): Set[A]

Crée une nouvelle collection immuable en supprimant les éléments contenus dans la collection spécifiée
9

addString(b: StringBuilder): StringBuilder

Ajoute tous les éléments de la collection immuable à un tampon de chaîne
10

def addString(b: StringBuilder, sep: String): StringBuilder

Ajoute tous les éléments de la collection immuable à un tampon de chaîne, en utilisant le séparateur spécifié
11

def apply(elem: A)

Vérifie si la collection contient l'élément spécifié
12

def count(p: (A) => Boolean): Int

Compte le nombre d'éléments de la collection qui satisfont à une condition spécifiée
13

def copyToArray(xs: Array[A], start: Int, len: Int): Unit

Copie les éléments d'une collection immuable dans un tableau
14

def diff(that: Set[A]): Set[A]

Compare la différence entre deux ensembles
15

def drop(n: Int): Set[A]]

Renvoie une nouvelle collection avec les n premiers éléments supprimés
16

def dropRight(n: Int): Set[A]

Renvoie une nouvelle collection avec les n derniers éléments supprimés
17

def dropWhile(p: (A) => Boolean): Set[A]

Supprime des éléments de gauche à droite jusqu'à ce que la condition p soit fausse
18

def equals(that: Any): Boolean

La méthode equals peut être utilisée pour n'importe quelle séquence. Elle sert à comparer si des séquences sont égales.
19

def exists(p: (A) => Boolean): Boolean

Détermine si un élément satisfaisant la condition spécifiée existe dans la collection immuable.
20

def filter(p: (A) => Boolean): Set[A]

Affiche tous les éléments de la collection immuable qui répondent à la condition spécifiée.
21

def find(p: (A) => Boolean): Option[A]

Trouve le premier élément de la collection immuable qui satisfait la condition spécifiée
22

def forall(p: (A) => Boolean): Boolean

Détermine si la condition spécifiée s'applique à tous les éléments de cette collection
23

def foreach(f: (A) => Unit): Unit

Applique une fonction à tous les éléments de la collection immuable
24

def head: A

Récupère le premier élément de la collection immuable
25

def init: Set[A]

Renvoie tous les éléments sauf le dernier
26

def intersect(that: Set[A]): Set[A]

Calcule l'intersection de deux ensembles
27

def isEmpty: Boolean

Détermine si la collection est vide
28

def iterator: Iterator[A]

Crée un nouvel itérateur pour parcourir les éléments
29

def last: A

Renvoie le dernier élément
30

def map[B](f: (A) => B): immutable.Set[B]

Recalcule tous les éléments en utilisant la méthode donnée
31

def max: A

Trouve le plus grand élément
32

def min: A

Trouve le plus petit élément
33

def mkString: String

Affiche tous les éléments de la collection sous forme de chaîne
34

def mkString(sep: String): String

Affiche tous les éléments de la collection sous forme de chaîne à l'aide d'un séparateur
35

def product: A

Renvoie le produit des éléments numériques de la collection immuable.
36

def size: Int

Renvoie le nombre d'éléments de la collection immuable
37

def splitAt(n: Int): (Set[A], Set[A])

Divise la collection immuable en deux conteneurs : le premier est constitué des n premiers éléments, et le second des éléments restants
38

def subsetOf(that: Set[A]): Boolean

Renvoie true si l'ensemble contient un sous-ensemble, sinon renvoie false
39

def sum: A

Renvoie la somme de tous les éléments numériques de la collection immuable
40

def tail: Set[A]

Renvoie les éléments d'une collection immuable à l'exception du premier élément
41

def take(n: Int): Set[A]

Renvoie les n premiers éléments
42

def takeRight(n: Int):Set[A]

Renvoie les n derniers éléments
43

def toArray: Array[A]

Convertit la collection en tableau
44

def toBuffer[B >: A]: Buffer[B]

Renvoie un buffer contenant tous les éléments de la collection immuable
45

def toList: List[A]

Renvoie une List contenant tous les éléments de la collection immuable
46

def toMap[T, U]: Map[T, U]

Renvoie une Map contenant tous les éléments de la collection immuable
47

def toSeq: Seq[A]

Renvoie une Seq contenant tous les éléments de la collection immuable
48

def toString(): String

Renvoie une représentation sous forme de chaîne de l'objet

Pour plus de méthodes, veuillez consulterla documentation de l'API

Scala 集合Collections Scala

Autres extensions