Prerrequisito: Ambientada en Scala | Serie 1
En
Establecer
, Solo podemos agregar nuevos elementos en un conjunto mutable.
+=, ++==
y
add()El método se usa para agregar nuevos elementos cuando estamos trabajando con un conjunto mutable en una colección mutable y += se usa para agregar nuevos elementos cuando estamos trabajando con
conjunto mutable
en colección inmutable.
Ejemplo 1:
// Scala program to illustrate how to
// add items using +=, ++== and add()
// method in mutable set with mutable
// collection
import scala.collection.mutable._
object Main
{
def main(args: Array[String])
{
// Creating and initilazing set
var myset = Set("G", "Geek", "for")
println("Set before addition "+
"of new elements:")
println(myset)
// Adding new element in set
// using += and ++==
myset += "Geeks"
// Here, "G" is already present in the
// Set so, "G" is not added in set
myset ++== List("Geeks12", "geek23", "G")
// Adding elements using add() method
myset.add("GeeksforGeeks")
myset.add("geeksForgeeks100")
println("\nSet after addition of new elements:")
println(myset)
}
}
Producción:
Set before addition of new elements: Set(for, G, Geek) Set after addition of new elements: Set(geek23, for, Geeks, G, Geek, Geeks12, geeksForgeeks100, GeeksforGeeks)
Ejemplo 2:
// Scala program to illustrate how
// to add items using += operator in
// mutable set with immutable collection
import scala.collection.immutable._
object Main
{
def main(args: Array[String])
{
// Creating and initializing mutable set
var myset = Set("G", "Geek", "for")
println("Set before addition" +
" of new elements:")
println(myset)
// Adding new element in set
// using += operator
myset += "GeeksforGeeks"
myset += "geeks1000"
println("\nSet after addition " +
"of new elements:")
println(myset)
}
}
Producción:
Set before addition of new elements: Set(G, Geek, for) Set after addition of new elements: Set(for, Geek, G, geeks1000, GeeksforGeeks)
En Set, solo podemos eliminar elementos en el conjunto mutable.
-=
y
–=
se utilizan métodos para eliminar elementos y también podemos utilizar
retain(),
clear(), y
remove()métodos para eliminar elementos cuando estamos trabajando con
conjunto mutable
en la colección mutable. -= El operador se usa para eliminar elementos cuando estamos trabajando con
conjunto mutable
en colección inmutable.
Ejemplo 1:
// Scala program to illustrate
// how to delete items using -=
// and --= methods in mutalbe set
// with mutable collection
import scala.collection.mutable._
object Main
{
def main(args: Array[String])
{
// Creating and initilazing
//mutable set
var myset = Set(100, 400, 500,
600, 300, 800)
println("Set before deletion:")
println(myset)
// Deleting elements in set
// using -= and --= methods
myset -= 600
myset --= List(300, 100)
println("\nSet after deletion:")
println(myset)
}
}
Producción:
Set before deletion: Set(300, 100, 800, 500, 600, 400) Set after deletion: Set(800, 500, 400)
Ejemplo 2:
// Scala program to illustrate
// how to delete items using
// retain(), and clear() methods
// in mutalbe set with mutable
// collection
import scala.collection.mutable._
object Main
{
def main(args: Array[String])
{
// Creating and initializing
// mutable set
var myset1 = Set(100, 400, 500,
600,300, 800)
var myset2 = Set(11, 44, 55, 66, 77)
println("Set before deletion:")
println(myset1)
println(myset2)
// Deleting elements in set
// using retain() method
myset1.retain(_>500)
println("\nSet after using retain()" +
" method:")
println(myset1)
// Deleting elements in set
// using clear() method
myset2. clear
println("\nSet after using clear() method:")
println(myset2)
}
}
Producción:
Set before deletion: Set(300, 100, 800, 500, 600, 400) Set(66, 55, 11, 44, 77) Set after using retain() method: Set(800, 600) Set after using clear() method: Set()
En
conjunto inmutable
, No podemos agregar elementos, pero podemos usar
+
y
++
operadores para agregar elementos del conjunto inmutable y almacenar el resultado en una nueva variable. Aquí, + se usa para agregar elementos únicos o múltiples y ++ se usa para agregar múltiples elementos definidos en otra secuencia y en la concatenación de un conjunto inmutable.
Ejemplo:
// Scala program to illustrate how
// to add elements in immutable set
import scala.collection.immutable._
object Main
{
def main(args: Array[String])
{
// Creating and initilazing
// immutable set
val myset1 = Set(100, 400, 500,
600,300, 800)
val myset2 = Set(11, 44, 55, 66, 77)
println("Set before addition:")
println(myset1)
println(myset2)
println("\nSet after addition:")
// Add single element in myset1
// and create new Set
val S1 = myset1 + 900
println(S1)
// Add multiple elements in myset1
// and create new Set
val S2 = myset1 + (200, 300)
println(S2)
// Add another list into myset1
// and create new Set
val S3 = myset1 ++ List(700, 1000)
println(S3)
// Add another set myset2 into
// myset1 and create new Set
val S4 = myset1 ++ myset2
println(S4)
}
}
Producción:
Set before addition: Set(500, 600, 800, 300, 400, 100) Set(77, 44, 66, 11, 55) Set after addition: Set(500, 900, 600, 800, 300, 400, 100) Set(500, 600, 800, 300, 400, 200, 100) Set(500, 700, 1000, 600, 800, 300, 400, 100) Set(500, 77, 44, 66, 600, 11, 55, 800, 300, 400, 100)
En
conjunto inmutable
, No podemos quitar elementos, pero podemos usar
–
y
—
operadores para eliminar elementos del conjunto inmutable y almacenar el resultado en una nueva variable. Aquí, el operador – se usa para eliminar uno o más elementos y el operador – se usa para eliminar múltiples elementos definidos en otra secuencia.
Ejemplo:
// Scala program to illustrate how
// to remove elements in immutable set
import scala.collection.immutable._
object Main
{
def main(args: Array[String])
{
// Creating and initilazing
// immutable set
val myset = Set(100, 400, 500, 600,
300, 800, 900, 700)
println("Set before deletion:")
println(myset)
println("\nSet after deletion:")
// Remove single element in myset and
// Result store into new variable
val S1 = myset - 100
println(S1)
// Remove multiple elements from myset
// Result store into new variable
val S2 = myset - (400, 300)
println(S2)
// Remove another list from myset
// Result store into new variable
val S3 = myset -- List(700, 500)
println(S3)
}
}
Producción:
Set before deletion: Set(500, 900, 700, 600, 800, 300, 400, 100) Set after deletion: Set(500, 900, 700, 600, 800, 300, 400) Set(500, 900, 700, 600, 800, 100) Set(900, 600, 800, 300, 400, 100)
Ahora veremos algunos de los básicos.
Operaciones matemáticas
en el Conjunto como Unión, Intersección y Diferencia.
- Unión: En esto, podríamos simplemente agregar un Conjunto con otro. Dado que el Conjunto en sí mismo no permitirá ninguna entrada duplicada, no es necesario que nos ocupemos de los valores comunes. Para realizar la unión, usamos el método union().
- Intersección: para obtener los valores comunes de ambos conjuntos, usamos el método intersect(). Devuelve un nuevo conjunto que contiene todos los valores comunes presentes en ambos conjuntos.
- Diferencia: Para obtener la diferencia de dos Conjuntos usamos el método diff(). Devuelve el conjunto que contiene todos los que no están presentes en myset2.
Ejemplo:
// Scala program to illustrate union,
// intersection, and difference on Set
import scala.collection.immutable._
object Main
{
def main(args: Array[String])
{
// Creating and initializing set
val myset1 = Set(11, 22, 33, 44,
55, 66, 77, 111)
val myset2 = Set(88, 22, 99, 44,
55, 66, 77)
// To find intersection
val S1 = myset1.intersect(myset2)
println("Intersection:")
println(S1)
// To find the symmetric difference
val S2 = myset1.diff(myset2)
println("\nDifference:")
println(S2)
// To find union
val S3 = myset1.union(myset2)
println("\nUnion:")
println(S3)
}
}
Producción:
Intersection: Set(77, 22, 44, 66, 55) Difference: Set(33, 11, 111) Union: Set(88, 33, 77, 22, 44, 66, 11, 99, 55, 111)
Publicación traducida automáticamente
Artículo escrito por ankita_saini y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA