Scala Set (conjunto)

Scala 集合Colecciones de Scala

Scala Set (conjunto) es una colección de objetos sin duplicados, todos los elementos son únicos.

Las colecciones de Scala se dividen en colecciones mutables e inmutables.

Por defecto, Scala utiliza colecciones inmutables. Si deseas usar colecciones mutables, necesitas importarscala.collection.mutable.Setel paquete.

Por defecto se importa scala.collection.immutable.Set. Un ejemplo de colección inmutable es el siguiente:

Ejemplo

val set = Set(1,2,3)
println(set.getClass.getName) //

println(set.exists(_ % 2 == 0)) //true
println(set.drop(1)) //Set(2,3)

Si necesitas usar colecciones mutables, debes importar scala.collection.mutable.Set:

Ejemplo

import scala.collection.mutable.Set // se puede importar la colección mutable en cualquier lugar

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

Nota:Aunque el Set mutable y el Set inmutable tienen operaciones para agregar o eliminar elementos, hay una gran diferencia. Al operar sobre un Set inmutable, se produce un nuevo Set, el Set original no cambia, igual que List. Al operar sobre un Set mutable, se modifica el propio Set, similar a ListBuffer.

Operaciones básicas de conjuntos

Las colecciones de Scala tienen tres operaciones básicas:

  • headDevuelve el primer elemento del conjunto
  • tailDevuelve un conjunto que contiene todos los elementos excepto el primero
  • isEmptyDevuelve true si el conjunto está vacío

Cualquier operación sobre colecciones de Scala puede expresarse usando estas tres operaciones básicas. Ejemplo:

Ejemplo

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

      println( "El primer sitio web es : " + site.head )
      println( "El último sitio web es : " + site.tail )
      println( "Comprobar si la lista site está vacía : " + site.isEmpty )
      println( "Comprobar si nums está vacío : " + nums.isEmpty )
   }
}

Al ejecutar el código anterior, el resultado es:

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

Unir conjuntos

Puedes usar++el operador oSet.++()el método para unir dos conjuntos. Si hay elementos duplicados, se eliminarán. Ejemplo:

Ejemplo

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

      // ++ usado como operador
      var site = site1 ++ site2
      println( "site1 ++ site2 : " + site )

      // ++ usado como método
      site = site1.++(site2)
      println( "site1.++(site2) : " + site )
   }
}

Al ejecutar el código anterior, el resultado es:

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

Buscar el elemento máximo y mínimo en un conjunto

Puedes usarSet.minel método para buscar el elemento mínimo en el conjunto, y usaSet.maxel método para buscar el elemento máximo en el conjunto. Ejemplo:

Ejemplo

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

      // Buscar el elemento máximo y mínimo en el conjunto
      println( "El elemento mínimo en el conjunto Set(5,6,9,20,30,45) es : " + num.min )
      println( "El elemento máximo en el conjunto Set(5,6,9,20,30,45) es : " + num.max )
   }
}

Al ejecutar el código anterior, el resultado es:

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

Intersección

Puedes usarSet.&el método oSet.intersectel método para ver los elementos de la intersección de dos conjuntos. Ejemplo:

Ejemplo

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)

      // Intersección
      println( "num1.&(num2) : " + num1.&(num2) )
      println( "num1.intersect(num2) : " + num1.intersect(num2) )
   }
}

Al ejecutar el código anterior, el resultado es:

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

Métodos comunes de Scala Set

La siguiente tabla enumera los métodos comunes de Scala Set:

N.º Método y descripción
1

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

Agrega un nuevo elemento x al conjunto y crea un nuevo conjunto, a menos que el elemento ya exista.
2

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

Elimina un elemento del conjunto y crea un nuevo conjunto.
3

def contains(elem: A): Boolean

Si el elemento existe en el conjunto, devuelve true; de lo contrario, devuelve false.
4

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

Devuelve la intersección de dos conjuntos.
5

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

Devuelve la diferencia de dos conjuntos.
6

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

Crea un nuevo conjunto inmutable agregando los elementos del conjunto especificado.
7

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

Combina dos conjuntos.
8

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

Crea un nuevo conjunto inmutable eliminando los elementos del conjunto especificado.
9

def addString(b: StringBuilder): StringBuilder

Agrega todos los elementos del conjunto inmutable al búfer de cadenas.
10

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

Agrega todos los elementos del conjunto inmutable al búfer de cadenas, utilizando el separador especificado.
11

def apply(elem: A)

Comprueba si el conjunto contiene el elemento especificado.
12

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

Cuenta el número de elementos del conjunto que cumplen la condición especificada.
13

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

Copia los elementos del conjunto inmutable a un array.
14

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

Compara la diferencia de dos conjuntos.
15

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

Devuelve un nuevo conjunto descartando los primeros n elementos.
16

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

Devuelve un nuevo conjunto descartando los últimos n elementos.
17

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

Descarta elementos de izquierda a derecha hasta que la condición p no se cumpla.
18

def equals(that: Any): Boolean

El método equals se puede usar en cualquier secuencia. Se utiliza para comparar si las secuencias son iguales.
19

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

Determina si existe un elemento del conjunto inmutable que cumpla la condición especificada.
20

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

Muestra todos los elementos del conjunto inmutable que cumplen la condición especificada.
21

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

Busca el primer elemento del conjunto inmutable que cumpla la condición especificada.
22

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

Comprueba si la condición especificada se aplica a todos los elementos de este conjunto.
23

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

Aplica una función a todos los elementos del conjunto inmutable.
24

def head: A

Obtiene el primer elemento del conjunto inmutable.
25

def init: Set[A]

Devuelve todos los elementos excepto el último.
26

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

Calcula la intersección de dos conjuntos.
27

def isEmpty: Boolean

Determina si el conjunto está vacío.
28

def iterator: Iterator[A]

Crea un nuevo iterador para recorrer los elementos.
29

def last: A

Devuelve el último elemento.
30

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

Recalcula todos los elementos mediante el método dado.
31

def max: A

Busca el elemento máximo.
32

def min: A

Busca el elemento mínimo.
33

def mkString: String

Muestra todos los elementos del conjunto como una cadena.
34

def mkString(sep: String): String

Muestra todos los elementos del conjunto como una cadena usando un separador.
35

def product: A

Devuelve el producto de los elementos numéricos del conjunto inmutable.
36

def size: Int

Devuelve el número de elementos del conjunto inmutable.
37

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

Divide el conjunto inmutable en dos contenedores: el primero formado por los primeros n elementos y el segundo por los elementos restantes.
38

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

Devuelve true si el conjunto contiene un subconjunto; de lo contrario, devuelve false.
39

def sum: A

Devuelve la suma de todos los elementos numéricos del conjunto inmutable.
40

def tail: Set[A]

Devuelve un conjunto inmutable con todos los elementos excepto el primero.
41

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

Devuelve los primeros n elementos.
42

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

Devuelve los últimos n elementos.
43

def toArray: Array[A]

Convierte el conjunto en un array.
44

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

Devuelve un búfer que contiene todos los elementos del conjunto inmutable.
45

def toList: List[A]

Devuelve una List que contiene todos los elementos del conjunto inmutable.
46

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

Devuelve un Map que contiene todos los elementos del conjunto inmutable.
47

def toSeq: Seq[A]

Devuelve una Seq que contiene todos los elementos del conjunto inmutable.
48

def toString(): String

Devuelve una cadena que representa al objeto.

Para más métodos, consulta ladocumentación de la API.

Scala 集合Colecciones de Scala

Otras extensiones