Un conjunto es una colección que solo contiene elementos únicos. En Scala, están disponibles conjuntos mutables e inmutables. El conjunto mutable es aquel conjunto en el que el valor del objeto cambia, pero, en el conjunto inmutable, el valor del objeto en sí mismo no cambia. El conjunto inmutable se define en Scala.collection.immutable._ paquete y el conjunto mutable se define en Scala.collection.mutable._ paquete. Aquí, discutiremos algunos métodos importantes del paquete Scala.collection.immutable._.
1. def +(elem: A): Set[A]: este método se usa para agregar un elemento al conjunto y luego lo devuelve.
Ejemplo :
// Scala program of +()
// method
// Creating object
object GfG
{
// Main method
def main(args:Array[String])
{
// Creating a set
val s = Set(8, 9, 1, 4, 2, 7)
// Applying +() method
val result = s.+(6)
// Display output
print(result)
}
}
Producción:
Set(1, 6, 9, 2, 7, 8, 4)
2. def -(elem: A): Set[A]: este método se usa para eliminar el elemento del conjunto y luego lo devuelve.
Ejemplo :
// Scala program of -()
// method
// Creating object
object GfG
{
// Main method
def main(args:Array[String])
{
// Creating a set
val s = Set(8, 9, 1, 4, 2, 7)
// Applying -() method
val result = s.-(1)
// Display output
print(result)
}
}
Producción:
Set(9, 2, 7, 8, 4)
3. def contiene (elem: A): booleano: este método devuelve verdadero si el conjunto contiene el elemento especificado. De lo contrario, devolverá falso.
Ejemplo :
// Scala program of contains()
// method
// Creating object
object GfG
{
// Main method
def main(args:Array[String])
{
// Creating a set
val s = Set(8, 9, 1, 4, 2, 7)
// Applying contains() method
val result = s.contains(1)
// Display output
print(result)
}
}
Producción:
true
4. def &(eso: Conjunto[A]): Conjunto[A]: este método se utiliza para devolver una intersección de dos conjuntos.
Ejemplo :
// Scala program of &()
// method
// Creating object
object GfG
{
// Main method
def main(args:Array[String])
{
// Creating a set
val s1 = Set(8, 9, 1, 4, 2, 7)
val s2 = Set(3, 4, 6, 8)
// Applying &() method
val result = s1.&(s2)
// Display output
print(result)
}
}
Producción:
Set(8, 4)
5. def &~(que: Conjunto[A]): Conjunto[A] – Este símbolo significa diferencia de conjuntos.
Ejemplo :
// Scala program of &~()
// method
// Creating object
object GfG
{
// Main method
def main(args:Array[String])
{
// Creating a set
val s1 = Set(8, 9, 1, 4, 2, 7)
val s2 = Set(3, 4, 6, 8)
// Applying &~() method
val result = s1.&~(s2)
// Display output
print(result)
}
}
Producción:
Set(1, 9, 2, 7)
6. def +(elem1: A, elem2: A, elems: A*): Set[A]: este método se usa para agregar varios elementos a un conjunto de Scala y luego lo devuelve.
Ejemplo :
// Scala program of +()
// method
// Creating object
object GfG
{
// Main method
def main(args:Array[String])
{
// Creating a set
val s = Set(8, 9, 1, 4, 2, 7)
// Applying +() method
val result = s.+(3, 4, 6)
// Display output
print(result)
}
}
Producción:
Set(1, 6, 9, 2, 7, 3, 8, 4)
7. def ++(elementos: A): Conjunto[A]: este método se utiliza para la concatenación de un conjunto con otro.
Ejemplo :
// Scala program of ++()
// method
// Creating object
object GfG
{
// Main method
def main(args:Array[String])
{
// Creating a set
val s1 = Set(8, 9, 1, 4, 2, 7)
val s2 = Set(3, 4, 6)
// Applying ++() method
val result = s1 ++ s2
// Display output
print(result)
}
}
Producción:
Set(1, 6, 9, 2, 7, 3, 8, 4)
8. def -(elem1: A, elem2: A, elems: A*): Set[A]: este método se usa para eliminar cada elemento mencionado del conjunto.
Ejemplo :
// Scala program of -()
// method
// Creating object
object GfG
{
// Main method
def main(args:Array[String])
{
// Creating a set
val s = Set(8, 9, 1, 4, 2, 7)
// Applying -() method
val result = s.-(8, 1, 3)
// Display output
print(result)
}
}
Producción:
Set(9, 2, 7, 4)
9. def addString(b: StringBuilder): StringBuilder: este método se usa para agregar todos los elementos del conjunto al String Builder.
Ejemplo :
// Scala program of addString()
// method
// Creating object
object GfG
{
// Main method
def main(args:Array[String])
{
// Creating a set
val s = Set(8, 9, 1, 4, 2, 7)
// Applying addString() method
val result = s.addString(new StringBuilder())
// Display output
print(result)
}
}
Producción:
192784
10. def addString(b: StringBuilder, sep: String): StringBuilder: este método se usa como separador de la funcionalidad anterior.
Ejemplo :
// Scala program of addString()
// method
// Creating object
object GfG
{
// Main method
def main(args:Array[String])
{
// Creating a set
val s = Set(8, 9, 1, 4, 2, 7)
// Applying addString() method
val result = s.addString(new StringBuilder(), "*")
// Display output
print(result)
}
}
Producción:
1*9*2*7*8*4
11. def apply(elem: A) – Este método se usa para verificar si el elemento es parte del conjunto o no. Devuelve el valor booleano Verdadero o Falso.
Ejemplo :
// Scala program of apply()
// method
// Creating object
object GfG
{
// Main method
def main(args:Array[String])
{
// Creating a set
val s = Set(8, 9, 1, 4, 2, 7)
// Applying apply() method
val result = s.apply(2)
// Display output
print(result)
}
}
Producción:
true
12. def drop(n: Int): Set[A]] – Este método se usa para devolver todos los elementos excepto el primero n.
Ejemplo :
// Scala program of drop()
// method
// Creating object
object GfG
{
// Main method
def main(args:Array[String])
{
// Creating a set
val s = Set(2, 3, 5, 7, 8)
// Applying drop() method
val result = s.drop(2)
// Display output
print(result)
}
}
Producción:
Set(7, 3, 8)
13. def dropRight(n: Int): Set[A] – Este método se usa para devolver todos los elementos excepto el último n que es justo lo opuesto al método anterior().
Ejemplo :
// Scala program of dropRight()
// method
// Creating object
object GfG
{
// Main method
def main(args:Array[String])
{
// Creating a set
val s = Set(1, 2, 3, 5, 7, 9)
// Applying dropRight() method
val result = s.dropRight(2)
// Display output
print(result)
}
}
Producción:
Set(5, 1, 9, 2)
14. def equals(that: Any): Boolean: este método se usa para comparar el conjunto con otra secuencia.
Ejemplo :
// Scala program of equals()
// method
// Creating object
object GfG
{
// Main method
def main(args:Array[String])
{
// Creating a set
val s = Set(2, 3, 5, 7, 8)
// Applying equals() method
val result = s.equals(Set(2, 3, 5, 7, 8))
// Display output
print(result)
}
}
Producción:
true
15. def head: A: este método se utiliza para devolver el primer elemento del conjunto.
Ejemplo :
// Scala program of head()
// method
// Creating object
object GfG
{
// Main method
def main(args:Array[String])
{
// Creating a set
val s = Set(1, 2, 3, 5, 7, 9)
// Applying head() method
val result = s.head
// Display output
print(result)
}
}
Producción:
5
16. def init: Set[A]: este método se utiliza para devolver todos los elementos del conjunto, excepto el último.
Ejemplo :
// Scala program of init()
// method
// Creating object
object GfG
{
// Main method
def main(args:Array[String])
{
// Creating a set
val s = Set(1, 2, 3, 5, 7, 9)
// Applying init() method
val result = s.init
// Display output
print(result)
}
}
Producción:
Set(5, 1, 9, 2, 7)
17. def intersect(that: Set[A]): Set[A]: este método se usa para devolver la intersección de dos conjuntos, es decir, devuelve el elemento común de los dos conjuntos.
Ejemplo :
// Scala program of intersect()
// method
// Creating object
object GfG
{
// Main method
def main(args:Array[String])
{
// Creating a set
val s1 = Set(1, 2, 3, 5, 7, 9)
val s2 = Set(1, 2, 3, 4, 9, 9)
// Applying intersect() method
val result = s1.intersect(s2)
// Display output
print(result)
}
}
Producción:
Set(1, 9, 2, 3)
18. def isEmpty: Boolean: este método devuelve verdadero si el conjunto dado está vacío. De lo contrario, devolverá False.
Ejemplo :
// Scala program of isEmpty()
// method
// Creating object
object GfG
{
// Main method
def main(args:Array[String])
{
// Creating a set
val s = Set(2, 3, 5, 7, 8)
// Applying isEmpty() method
val result = s.isEmpty
// Display output
print(result)
}
}
Producción:
false
19. def iterator: Iterator[A]: este método ayuda a crear un nuevo iterador sobre el conjunto.
Ejemplo :
// Scala program of iterator()
// method
// Creating object
object GfG
{
// Main method
def main(args:Array[String])
{
// Creating a set
val s = Set(2, 3, 5, 7, 8)
// Applying iterator() method
val result = s.iterator
// Display output
print(result)
}
}
Producción:
non-empty iterator
20. def last: A: este método ayuda a devolver el último elemento de un conjunto.
Ejemplo :
// Scala program of last()
// method
// Creating object
object GfG
{
// Main method
def main(args:Array[String])
{
// Creating a set
val s = Set(1, 2, 3, 5, 7, 9)
// Applying last() method
val result = s.last
// Display output
print(result)
}
}
Producción:
3
21. def max: A: este método se utiliza para devolver el valor más alto del conjunto.
Ejemplo :
// Scala program of max()
// method
// Creating object
object GfG
{
// Main method
def main(args:Array[String])
{
// Creating a set
val s = Set(2, 3, 5, 7, 8)
// Applying max() method
val result = s.max
// Display output
print(result)
}
}
Producción:
8
22. def min: A: este método se utiliza para devolver el elemento más bajo del conjunto.
Ejemplo :
// Scala program of min()
// method
// Creating object
object GfG
{
// Main method
def main(args:Array[String])
{
// Creating a set
val s = Set(1, 2, 3, 5, 7, 9)
// Applying min() method
val result = s.min
// Display output
print(result)
}
}
Producción:
1
23. def mkString: String: este método ayuda a representar todos los elementos del conjunto como una string.
Ejemplo :
// Scala program of mkString()
// method
// Creating object
object GfG
{
// Main method
def main(args:Array[String])
{
// Creating a set
val s = Set(2, 3, 5, 7, 8)
// Applying mkString() method
val result = s.mkString
// Display output
print(result)
}
}
Producción:
52738
24. producto def: A: este método se utiliza para devolver el producto de todos los elementos del conjunto.
Ejemplo :
// Scala program of product()
// method
// Creating object
object GfG
{
// Main method
def main(args:Array[String])
{
// Creating a set
val s = Set(1, 2, 3, 5, 7, 9)
// Applying product() method
val result = s.product
// Display output
print(result)
}
}
Producción:
1890
25. tamaño def: Int: este método se utiliza para devolver el tamaño del conjunto.
Ejemplo :
// Scala program of size()
// method
// Creating object
object GfG
{
// Main method
def main(args:Array[String])
{
// Creating a set
val s = Set(2, 3, 5, 7, 8)
// Applying size() method
val result = s.size
// Display output
print(result)
}
}
Producción:
5
26. def sum: A – Este método se usa para devolver la suma de todos los elementos del conjunto.
Ejemplo :
// Scala program of sum()
// method
// Creating object
object GfG
{
// Main method
def main(args:Array[String])
{
// Creating a set
val s = Set(1, 2, 3, 5, 7, 9)
// Applying sum() method
val result = s.sum
// Display output
print(result)
}
}
Producción:
27
27. def tail: Set[A]: este método se utiliza para devolver todos los elementos del conjunto excepto el primero.
Ejemplo :
// Scala program of tail()
// method
// Creating object
object GfG
{
// Main method
def main(args:Array[String])
{
// Creating a set
val s = Set(2, 3, 5, 7, 8)
// Applying tail() method
val result = s.tail
// Display output
print(result)
}
}
Producción:
Set(2, 7, 3, 8)
28. def take(n: Int): Set[A]: este método se usa para devolver los primeros n elementos del conjunto.
Ejemplo :
// Scala program of take()
// method
// Creating object
object GfG
{
// Main method
def main(args:Array[String])
{
// Creating a set
val s = Set(1, 2, 3, 5, 7, 9)
// Applying take() method
val result = s.take(3)
// Display output
print(result)
}
}
Producción:
Set(5, 1, 9)
Aquí hay algunos métodos más que se llaman en un conjunto.
| Método | Descripción |
|---|---|
| def &(que: Conjunto[A]): Conjunto[A] | Este método ayuda a devolver una intersección de dos conjuntos. |
| def contar(p: (A) => Booleano): Int | Este método se utiliza para devolver el recuento de elementos que satisfacen el predicado. |
| def diff(que: Conjunto[A]): Conjunto[A] | Este método se utiliza para devolver la diferencia del conjunto (elementos que existen en un conjunto, pero no en otro). |
| def dropWhile(p: (A) => Boolean): Set[A] | Este método se usa para soltar elementos hasta el primer elemento que no satisface el predicado. |
| def existe(p: (A) => Booleano): Booleano | Este método se usa para devolver verdadero si el predicado es verdadero; de lo contrario, devuelve falso. |
| def filtro(p: (A) => Booleano): Establecer[A] | Este método se utiliza para filtrar elementos. |
| def encontrar(p: (A) => Booleano): Opción[A] | Este método se utiliza para devolver el primer elemento que satisface el predicado. |
| def forall(p: (A) => Booleano): Booleano | Este método se usa para devolver verdadero si todos los elementos del conjunto satisfacen el predicado. De lo contrario, falso. |
| def map[B](f: (A) => B): inmutable.Set[B] | Este método se utiliza para aplicar la función a todos los elementos del conjunto y devolverla. |
| def splitAt(n: Int): (Conjunto[A], Conjunto[A]) | Este método se usa para dividir el conjunto en el índice dado y devuelve los dos subconjuntos resultantes. |
| def subconjuntoDe(que: Conjunto[A]): Booleano | Este método se usa para devolver verdadero si el conjunto pasado como argumento es un subconjunto de este conjunto; de lo contrario, devuelve falso. |
| def tomarDerecha(n: Int):Establecer[A] | Este método se utiliza para devolver los últimos n elementos. |
| def aArray: Array[A] | Este método se utiliza para devolver un Array que contiene elementos del conjunto. |
| def aLista: Lista[A] | Este método se utiliza para devolver una Lista de elementos del conjunto. |
| def toSeq: Seq[A] | Este método se utiliza para devolver una secuencia del conjunto. |
| def toString(): String | Este método representa los elementos del conjunto como un String. |