Latest web development tutorials

Scala Set (collection)

collections Scala collections Scala

Scala Set (collection) ne se répète pas la collection d'objets, tous les éléments sont uniques.

collection Scala est divisé en collections variables et immuables.

Par défaut, Scala en utilisant les collections immuables, si vous souhaitez utiliser l'ensemble variable, vous devez référencer packagescala.collection.mutable.Set.

Le scala.collection.immutable.Set de référence par défaut, ensemble immuable des exemples sont les suivants: 

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 une collection de variable doivent introduire scala.collection.mutable.Set: 

import scala.collection.mutable.Set // 可以在任何地方引入 可变集合

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

Note: Bien que variable et immuable Set Set a ajouter ou supprimer des éléments, mais il y a une très grande différence.Une opération Set immuable, va produire une nouvelle série, le jeu original n'a pas changé, ce qui est la même que la liste. L'opération du changement de variable Set est que l'ensemble lui-même, semblable à ListBuffer.

Collection des opérations de base

collection Scala dispose de trois opérations de base:

  • head renvoie le premier élément de la collection
  • la tail retourne une collection qui contient , en plus des autres éléments du premier élément
  • isEmpty retourne true si la collection est vide

Toute opération pour les collections Scala peut être utilisé pour exprimer les trois opérations de base. Des exemples sont les suivants: 

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

      println( "第一网站是 : " + site.head )
      println( "最后一个网站是 : " + site.tail )
      println( "查看列表 site 是否为空 : " + site.isEmpty )
      println( "查看 nums 是否为空 : " + nums.isEmpty )
   }
}

Mise en œuvre du code ci-dessus, la sortie est: 

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

Kit de raccordement

Vous pouvez utiliser l'opérateur++ ou Set. ++ ()Méthode pour connecter deux ensembles. S'il y a des éléments en double seront supprimer les doublons. Des exemples sont les suivants: 

object Test {
   def main(args: Array[String]) {
      val site1 = Set("w3big", "Google", "Baidu")
      val site2 = Set("Faceboook", "Taobao")

      // ++ 作为运算符使用
      var site = site1 ++ site2
      println( "site1 ++ site2 : " + site )

      //  ++ 作为方法使用
      site = site1.++(site2)
      println( "site1.++(site2) : " + site )
   }
}

Mise en œuvre du code ci-dessus, la sortie est: 

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

Trouver les éléments de maximum et minimum dans la collection

Vous pouvez utiliser la méthodeSet.min pour trouver le plus petit élément de la collection, utilisez manière Set.maxpour trouver le plus grand élément de la collection. Des exemples sont les suivants: 

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

      // 查找集合中最大与最小元素
      println( "Set(5,6,9,20,30,45) 集合中的最小元素是 : " + num.min )
      println( "Set(5,6,9,20,30,45) 集合中的最大元素是 : " + num.max )
   }
}

Mise en œuvre du code ci-dessus, la sortie est: 

$ 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 utiliser la méthode ou les méthodesSet. & Set.intersectpour voir l'intersection des deux ensembles d'éléments. Des exemples sont les suivants: 

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)

      // 交集
      println( "num1.&(num2) : " + num1.&(num2) )
      println( "num1.intersect(num2) : " + num1.intersect(num2) )
   }
}

Mise en œuvre du code ci-dessus, la sortie est: 

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

Scala Set méthode commune

Le tableau suivant présente l'Ensemble Scala méthodes couramment utilisées:

Non. Méthode et description
1

def + (elem: A): Réglez [A]

Ajouter un nouvel élément à la collection, x et créer une nouvelle collection, à moins que les éléments existants

2

def - (elem: A): Réglez [A]

Retrait des éléments de la collection, et de créer une nouvelle collection

3

def contient (elem: A): Boolean

Si l'élément est présent dans la collection, elle renvoie true, sinon retourne false.

4

def et (que: Set [A ]): Réglez [A]

Renvoie l'intersection de deux ensembles

5

def & ~ (que: Set [ A]): Réglez [A]

Renvoie la différence de jeu de deux ensembles

6

def + (elem1: A, elem2 : A, elems: A *): Réglez [A]

En ajoutant des éléments entrants de la collection spécifiée pour créer un nouvel ensemble de immuable

7

def ++ (elems: A): Réglez [A]

La fusion de deux collections

8

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

En supprimant les éléments de la collection spécifiée passé pour créer un nouvel ensemble de immuable

9

def addString (b: StringBuilder): StringBuilder

Ajouter tous les éléments de la collection à la mémoire tampon de chaîne immuable

10

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

Ajouter tous les éléments d'une collection immuable dans un tampon de chaîne, en utilisant le délimiteur spécifié

11

appliquer def (elem: A)

Détecter si la collection contient l'élément spécifié

12

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

Calculer le nombre d'éléments qui répondent aux critères spécifiés définis

13

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

Copier élément de collection immuable à un tableau

14

def diff (que: Set [A ]): Réglez [A]

On compare la différence définit deux jeux

15

def drop (n: Int): Réglez [A]]

La nouvelle collection avant rejets n éléments de retour

16

def dropRight (n: Int): Réglez [A]

Retour jeter les n derniers éléments de la nouvelle collection

17

def dropWhile (p: (A) => Boolean): Réglez [A]

élément Jeter gauche à droite, jusqu'à ce que la condition ne p satisfait

18

def est égal à (que: Tout):Boolean

est égale à la méthode peut être utilisée dans n'importe quel ordre. Pour comparer la série sont égaux.

19

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

Analyse ensemble immuable l'élément spécifié existe des conditions.

20

def filtre (p: (A) => Boolean): Réglez [A]

Sortie répond à tous les critères spécifiés éléments de collecte immuables.

21

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

Trouver le premier élément de la collection se rencontrent immuable les critères spécifiés

22

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

Trouver tous les éléments d'une collection immuable qui répond aux critères spécifiés

23

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

La fonction est appliquée à tous les éléments de la collection immuable

24

tête de def: A

Obtenez le premier élément de la collection immuable

25

def INIT: Réglez [A]

Renvoie tous les éléments, sauf le dernier

26

intersection def (que: Set [A ]): Réglez [A]

Calculer l'intersection de deux ensembles

27

def isEmpty: Boolean

Déterminer si la collection est vide

28

def iterator: Iterator [A]

Créer un nouveau iterator pour itérer les éléments

29

def dernière: A

Retourne le dernier élément

30

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

Grâce à une méthode donnée recalculera tous les éléments

31

def max: A

Trouver l'élément maximal

32

def min: A

Trouver le plus petit élément

33

def mkString: String

L'ensemble de tous les éléments de l'affichage sous forme de chaîne

34

def mkString (septembre: String): chaîne

Séparateurs réunira tous les éléments affichés sous forme de chaîne

35

produit def: A

Retourne un ensemble immuable de nombres dans les éléments de l'intrigue.

36

Taille du def: Int

Retourne le nombre d'éléments dans la collection immuable

37

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

La collection immuable est divisée en deux récipients, le premier par les premiers n éléments, et le second par les éléments restants

38

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

Si la collection contient un sous-ensemble renvoie true, sinon false

39

def somme: A

Retourne un ensemble immuable de tous les éléments du numérique et

40

def queue: Réglez [A]

Retourne un ensemble immuable d'autres éléments en plus du premier élément

41

prendre def (n: Int): Réglez [A]

Renvoie les n premiers éléments

42

def takeRight (n: Int): Réglez [A]

n éléments Retour

43

def toArray: Array [A]

Sera converti en une collection numérisée

44

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

tampon Retour, contient tous les éléments d'une collection d'immuable

45

def toList: Liste [A]

Liste Retour, contient tous les éléments d'une collection d'immuable

46

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

Retour Plan, contient tous les éléments d'une collection d'immuable

47

def toSeq: Seq [A]

Retour Seq, contient tous les éléments d'une collection d'immuable

48

def toString (): String

Renvoie une chaîne à l'objet pour représenter

D' autres façons de se référer à la documentation de l' API

collections Scala collections Scala