Scala es un lenguaje de programación multiparadigma, de alto nivel y de propósito general. Es un lenguaje de programación puro orientado a objetos que también brinda soporte al enfoque de programación funcional. Los programas de Scala se pueden convertir a bytecodes y se pueden ejecutar en la JVM (Java Virtual Machine). Scala significa lenguaje escalable. Scala no proporciona soporte para .Net Framework. Scala fue diseñado por Martin Odersky, profesor de métodos de programación en École Polytechnique Fédérale de Lausanne (EPFL) en Suiza y científico informático alemán. Scala se lanzó públicamente por primera vez en 2004 en la plataforma Java como su primera versión. En junio de 2004. La última versión de scala es 2.12.6, que se lanzó el 27 de abril de 2018.
Temas:
Scala tiene muchas razones para ser popular y demandado. Algunas de las razones se mencionan a continuación:
- Orientado a objetos: cada valor en Scala es un objeto, por lo que es un lenguaje de programación puramente orientado a objetos. El comportamiento y el tipo de objetos están representados por las clases y rasgos en Scala.
- Funcional: también es un lenguaje de programación funcional ya que cada función es un valor y cada valor es un objeto. Proporciona soporte para funciones de orden superior, funciones anidadas, funciones anónimas, etc.
- Estáticamente tipificado: el proceso de verificar y hacer cumplir las restricciones de los tipos se realiza en tiempo de compilación en Scala. A diferencia de otros lenguajes de programación tipificados estáticamente como C++, C, etc., Scala no espera el tipo de información redundante del usuario. En la mayoría de los casos, el usuario no necesita especificar un tipo.
- Extensible: se pueden agregar nuevas construcciones de lenguaje a Scala en forma de bibliotecas. Scala está diseñado para interpolar con JRE (Java Runtime Environment).
- Procesamiento concurrente y sincronizado: Scala permite al usuario escribir los códigos de una manera inmutable que facilita la aplicación del paralelismo (sincronización) y la concurrencia.
Área de aplicación
Scala es un lenguaje muy compatible y, por lo tanto, puede instalarse fácilmente en los sistemas operativos Windows y Unix, ambos muy fácilmente.
Dado que Scala es muy similar sintácticamente a otros lenguajes ampliamente utilizados, es más fácil codificar y aprender en Scala. Los programas de scala se pueden escribir en cualquier editor de texto sin formato como el bloc de notas, el bloc de notas ++ o cualquier otro de ese tipo. También se puede usar un IDE en línea para escribir códigos Scala o incluso puede instalar uno en su sistema para que sea más factible escribir estos códigos porque los IDE brindan muchas características como editor de código intuitivo, depurador, compilador, etc.
Para empezar, escribir códigos Scala y realizar varias operaciones interesantes y útiles, uno debe tener Scala instalado en su sistema. Esto se puede hacer siguiendo las instrucciones paso a paso que se proporcionan a continuación:
- Verificación de paquetes de Java
Lo primero que debemos tener es un kit de desarrollo de software de Java (SDK) instalado en la computadora. Necesitamos verificar estos paquetes SDK y, si no están instalados, instalarlos. - Ahora instale Scala
Hemos terminado con la instalación de Java, ahora instalemos los paquetes de Scala. La mejor opción para descargar estos paquetes es descargarlos solo desde el sitio oficial: https://www.scala-lang.org/download/ Los paquetes en el enlace de arriba tienen aproximadamente 100 MB de almacenamiento. Una vez que se descargan los paquetes, abra el archivo .msi descargado. - Probar y ejecutar los comandos de Scala
Abra el símbolo del sistema ahora y escriba los siguientes códigos.
C:\Users\Your_PC_username>scala
- Recibiremos una salida como se muestra a continuación:
- Salida del comando.
Consideremos un simple programa Hola Mundo.
Scala
// Scala program to print Hello World
// Creating object
object Geeks {
// Main method
def main(args: Array[String])
{
// prints Hello, Geeks!
println("Hello, World!")
}
}
Producción:
Hello, World!
En general, hay dos formas de ejecutar un programa Scala:
- Uso de IDE en línea : podemos usar varios IDE en línea que se pueden usar para ejecutar programas Scala sin instalar.
- Uso de la línea de comandos: también podemos usar las opciones de la línea de comandos para ejecutar un programa Scala. Los pasos a continuación demuestran cómo ejecutar un programa Scala en la línea de comandos en el sistema operativo Windows/Unix:
Abra la línea de comandos y luego compile el código, escriba scala Hello.scala . Si su código no tiene ningún error, se ejecutará correctamente y se mostrará la salida.
Las variables son simplemente una ubicación de almacenamiento. Cada variable se conoce por su nombre y almacena alguna información conocida y desconocida conocida como valor. En Scala hay dos tipos de variables:
- Variables Mutables: Estas variables son aquellas variables que nos permiten cambiar un valor después de la declaración de una variable. Las variables mutables se definen utilizando la palabra clave «var».
- Variables inmutables: estas variables son aquellas variables que no le permiten cambiar un valor después de la declaración de una variable. Las variables inmutables se definen mediante el uso de la palabra clave «val».
Ejemplo:
// Mutable Variable var name: String = "geekforgeeks"; // Immutable Variable val name: String = "geekforgeeks";
Para saber más sobre las variables de Scala , consulte – Variables en Scala , Alcance de la variable en Scala .
Un operador es un símbolo que representa una operación a realizar con uno o más operandos. Los operadores nos permiten realizar diferentes tipos de operaciones en los operandos. Hay diferentes tipos de operadores utilizados en Scala de la siguiente manera:
- Operadores aritméticos
- Operadores relacionales
- Operadores logicos
- Operadores de Asignación
- Operadores bit a bit
Ejemplo :
Scala
// Scala program to demonstrate
// the Operators
// Creating object
object Geeks
{
// Main method
def main(args: Array[String])
{
// Operands
var a = 10;
var b = 4;
var c = true;
var d = false;
var result = 0;
// using arithmetic operators
println ("Addition is: "+ (a + b) );
println ("Subtraction is: "+ (a - b) ) ;
// using Relational Operators
if (a == b)
{
println ("Equal To Operator is True");
}
else
{
println ("Equal To Operator is False");
}
// using Logical Operator 'OR'
println("Logical Or of a || b = " + (c || d));
// using Bitwise AND Operator
result = a & b;
println ("Bitwise AND: " + result );
// using Assignment Operators
println ("Addition Assignment Operator: " + (a += b) );
}
}
Addition is: 14 Subtraction is: 6 Equal To Operator is False Logical Or of a || b = true Bitwise AND: 0 Addition Assignment Operator:()
La toma de decisiones en la programación es similar a la toma de decisiones en la vida real. Scala utiliza declaraciones de control para controlar el flujo de ejecución del programa en función de ciertas condiciones. Estos se utilizan para hacer que el flujo de ejecución avance y se bifurque en función de los cambios en el estado de un programa.
Declaraciones de toma de decisiones en Scala:
- Si
- si – más
- Anidado – Si
- si – escalera elsif
Ejemplo 1: para ilustrar el uso de if y if-else
Scala
// Scala program to illustrate the if and if-else statement
object Test
{
// Main Method
def main(args: Array[String])
{
// taking a variable
var a: Int = 650
// if condition to check
// for even number
if(a % 2 == 0)
{
println("Even Number")
}
if (a > 698)
{
// This statement will not
// execute as a > 698 is false
println("GeeksforGeeks")
}
else
{
// This statement will execute
println("Sudo Placement")
}
}
}
Even Number Sudo Placement
Ejemplo 2: Para ilustrar el uso de Nested-if
Scala
// Scala program to illustrate
// Nested if statement
object Test
{
// Main Method
def main(args: Array[String])
{
var a: Int = 10;
if(a % 2 == 0)
{
// Nested - if statement
// Will only be executed
// if above if statement
// is true
if(a % 5 == 0)
{
println("Number is divisible by 2 and 5\n")
}
}
}
}
Number is divisible by 2 and 5
Para obtener más información sobre la toma de decisiones, consulte Toma de decisiones en Scala
El bucle en los lenguajes de programación es una característica que facilita la ejecución de un conjunto de instrucciones/funciones repetidamente mientras alguna condición se evalúa como verdadera. Los bucles simplifican la tarea del programador. Scala proporciona los diferentes tipos de bucle para manejar la situación basada en condiciones en el programa. Los bucles en Scala son:
Scala
// Scala program to illustrate for loop
object forloopDemo {
// Main Method
def main(args: Array[String]) {
var y = 0;
// for loop execution with range
for(y <- 1 to 4)
{
println("Value of y is: " + y);
}
}
}
Value of y is: 1 Value of y is: 2 Value of y is: 3 Value of y is: 4
Scala
// Scala program to illustrate while loop
object whileLoopDemo
{
// Main method
def main(args: Array[String])
{
var x = 1;
// Exit when x becomes greater than 4
while (x <= 4)
{
println("Value of x: " + x);
// Increment the value of x for
// next iteration
x = x + 1;
}
}
}
Value of x: 1 Value of x: 2 Value of x: 3 Value of x: 4
Scala
// Scala program to illustrate do..while loop
object dowhileLoopDemo
{
// Main method
def main(args: Array[String])
{
var a = 10;
// using do..while loop
do
{
print(a + " ");
a = a - 1;
}while(a > 0);
}
}
10 9 8 7 6 5 4 3 2 1
Para obtener más información sobre los bucles, consulte Bucles en Scala
Array es un tipo especial de colección en scala. es una estructura de datos de tamaño fijo que almacena elementos del mismo tipo de datos. Es una colección de valores mutables. A continuación se muestra la sintaxis.
Sintaxis:
var arrayname = new Array[datatype](size)
Creará una array de enteros que contiene el valor 40, 55, 63, 17 y muchos más. A continuación se muestra la sintaxis para acceder a un solo elemento de una array, si hemos creado una array llamada número .
number(0)
Producirá la salida como 40.
Iterando a través de una array:
En este ejemplo, creamos una array mientras proporcionamos los valores de sus elementos al mismo tiempo. En este caso, se infiere el tipo.
Scala
// Scala program to accessing an array
// of the string as name.
object GFG
{
// Main method
def main(args: Array[String])
{
// allocating memory of 1D Array of string.
var name = Array("gfg", "geeks", "GeeksQuize",
"geeksforgeeks" )
println("second element of an array is: ")
// Accessing an array element
println(name(1) )
}
}
second element of an array is: geeks
Para obtener más información sobre las arrays, consulte Arrays en Scala
Una string es una secuencia de caracteres. En Scala, los objetos de String son inmutables, lo que significa una constante y no se pueden cambiar una vez creados. En Scala, se especifica un tipo de string antes de cumplir con el literal de string. pero cuando el compilador se encuentra con un literal de string y crea un objeto de string str.
Sintaxis:
var str = "Hello! GFG" or val str = "Hello! GFG" var str: String = "Hello! GFG" or val str: String = "Hello! GFG"
Scala
// Scala program to illustrate how to
// create a string
object Main
{
// str1 and str2 are two different strings
var str1 = "Hello! GFG"
val str2: String = "GeeksforGeeks"
def main(args: Array[String])
{
// Display both strings
println(str1);
println(str2);
}
}
Hello! GFG GeeksforGeeks
Concatenar strings en Scala:
cuando se crea una nueva string agregando dos strings, se conoce como concatenación de strings. Scala proporciona el método concat() para concatenar dos strings, este método devuelve una nueva string que se crea usando dos strings. También puede usar el operador ‘+’ para concatenar dos strings.
Scala
// Scala program to illustrate how to
// concatenate strings
object Main
{
// str1 and str2 are two strings
var str1 = "Welcome! GeeksforGeeks "
var str2 = " to Portal"
// Main function
def main(args: Array[String])
{
// concatenate str1 and str2 strings
// using concat() function
var Newstr = str1.concat(str2);
// Display strings
println("String 1:" +str1);
println("String 2:" +str2);
println("New String :" +Newstr);
// Concatenate strings using '+' operator
println("This is the tutorial" +
" of Scala language" +
" on GFG portal");
}
}
String 1:Welcome! GeeksforGeeks String 2: to Portal New String :Welcome! GeeksforGeeks to Portal This is the tutorial of Scala language on GFG portal
Para saber más sobre las strings, consulte Strings en Scala
Una función es una colección de sentencias que realizan una determinada tarea. Scala se asume como un lenguaje de programación funcional, por lo que estos juegan un papel importante. Facilita la depuración y modificación del código. Las funciones de Scala son valores de primera clase. A continuación se muestra la sintaxis de las funciones de Scala.
Sintaxis:
def function_name ([parameter_list]) : [return_type] = {
// function body
}
La palabra clave def se usa para declarar una función en Scala.
Llamada a función: Hay principalmente dos formas de llamar a la función en Scala. La primera forma es la forma estándar de la siguiente manera:
function_name(paramter_list)
En la segunda forma, un usuario también puede llamar a la función con la ayuda de la notación de instancia y punto de la siguiente manera:
[instance].function_name(paramter_list)
Scala
// Scala program of function calling
object GeeksforGeeks {
def main(args: Array[String]) {
// Calling the function
println("Sum is: " + functionToAdd(5, 3));
}
// declaration and definition of function
def functionToAdd(a:Int, b:Int) : Int =
{
var sum:Int = 0
sum = a + b
// returning the value of sum
return sum
}
}
Producción :
Sum is: 8
Funciones anónimas en Scala:
en Scala, una función anónima también se conoce como función literal. Una función que no contiene un nombre se conoce como función anónima.
Sintaxis:
(z:Int, y:Int)=> z*y Or (_:Int)*(_Int)
Scala
// Scala program to illustrate the anonymous method
object Main
{
def main(args: Array[String])
{
// Creating anonymous functions
// with multiple parameters Assign
// anonymous functions to variables
var myfc1 = (str1:String, str2:String) => str1 + str2
// An anonymous function is created
// using _ wildcard instead of
// variable name because str1 and
// str2 variable appear only once
var myfc2 = (_:String) + (_:String)
// Here, the variable invoke like a function call
println(myfc1("Geeks", "12Geeks"))
println(myfc2("Geeks", "forGeeks"))
}
}
Producción :
Geeks12Geeks GeeksforGeeks
Funciones anidadas de Scala:
una definición de función dentro de otra función se conoce como función anidada. En Scala, podemos definir funciones dentro de una función y las funciones definidas dentro de otras funciones se denominan funciones anidadas o locales.
Sintaxis:
def FunctionName1( perameter1, peramete2, ..) = {
def FunctionName2() = {
// code
}
}
Scala
// Scala program of Single Nested Function
object MaxAndMin
{
// Main method
def main(args: Array[String])
{
println("Min and Max from 5, 7")
maxAndMin(5, 7);
}
// Function
def maxAndMin(a: Int, b: Int) = {
// Nested Function
def maxValue() = {
if(a > b)
{
println("Max is: " + a)
}
else
{
println("Max is: " + b)
}
}
// Nested Function
def minValue() = {
if (a < b)
{
println("Min is: " + a)
}
else
{
println("Min is: " + b)
}
}
maxValue();
minValue();
}
}
Producción:
Min and Max from 5, 7 Max is: 7 Min is: 5
Currying Funciones en Scala:
Currying en Scala es simplemente una técnica o un proceso de transformación de una función. Esta función toma múltiples argumentos en una función que toma un solo argumento.
Sintaxis:
def function name(argument1, argument2) = operation
Scala
// Scala program add two numbers
// using currying Function
object Curry
{
// Define currying function
def add(x: Int, y: Int) = x + y;
def main(args: Array[String])
{
println(add(20, 19));
}
}
Producción:
39
La programación orientada a objetos tiene como objetivo implementar entidades del mundo real como herencia, ocultación, polimorfismo, etc. en la programación. El objetivo principal de OOP es unir los datos y las funciones que operan en ellos para que ninguna otra parte del código pueda acceder a estos datos excepto esa función.
Conceptos de programación orientada a objetos:
Creación de una Clase y un Objeto:
Las Clases y los Objetos son conceptos básicos de la Programación Orientada a Objetos que giran en torno a las entidades de la vida real. Una clase es un proyecto o prototipo definido por el usuario a partir del cual se crean objetos.
Scala
// A Scala program to illustrate
// how to create a class
// Name of the class is Smartphone
class Smartphone
{
// Class variables
var number: Int = 16
var nameofcompany: String = "Apple"
// Class method
def Display()
{
println("Name of the company : " + nameofcompany);
println("Total number of Smartphone generation: " + number);
}
}
object Main
{
// Main method
def main(args: Array[String])
{
// Class object
var obj = new Smartphone();
obj.Display();
}
}
Name of the company : Apple Total number of Smartphone generation: 16
Los rasgos son como interfaces en Java. Pero son más potentes que la interfaz en Java porque en las características se le permite implementar los miembros. Los rasgos pueden tener métodos (tanto abstractos como no abstractos) y campos como sus miembros.
Creando un rasgo –
Scala
// Scala program to illustrate how to
// create traits
// Trait
trait MyTrait
{
def pet
def pet_color
}
// MyClass inherits trait
class MyClass extends MyTrait
{
// Implementation of methods of MyTrait
def pet()
{
println("Pet: Dog")
}
def pet_color()
{
println("Pet_color: White")
}
// Class method
def pet_name()
{
println("Pet_name: Dollar")
}
}
object Main
{
// Main method
def main(args: Array[String])
{
val obj = new MyClass();
obj.pet();
obj.pet_color();
obj.pet_name();
}
}
Producción :
Pet: Dog Pet_color: White Pet_name: Dollar
Para obtener más información sobre los rasgos, consulte Rasgos en Scala
Las expresiones regulares explican un patrón común utilizado para hacer coincidir una serie de datos de entrada, por lo que es útil en la coincidencia de patrones en numerosos lenguajes de programación. En Scala, las expresiones regulares generalmente se denominan Scala Regex.
Scala
// Scala program for Regular
// Expressions
// Creating object
object GfG
{
// Main method
def main(args
: Array[String])
{
// Applying r() method
val portal = "GeeksforGeeks".r
val CS
= "GeeksforGeeks is a CS portal."
// Displays the first match
println(portal findFirstIn CS)
}
}
Producción :
Some(GeeksforGeeks)
Para obtener más información sobre la tupla, consulte Expresiones regulares en Scala .
Una excepción es un evento no deseado o inesperado que ocurre durante la ejecución de un programa, es decir, en tiempo de ejecución. Estos eventos cambian el control de flujo del programa en ejecución.
En scala, todas las excepciones están desmarcadas. no existe el concepto de excepción comprobada Scala facilita una gran flexibilidad en términos de la capacidad de elegir si capturar una excepción.
Las excepciones de lanzamiento:
Scala
// Scala program of throw keyword
// Creating object
object Main
{
// Define function
def validate(article:Int)=
{
// Using throw keyword
if(article < 20)
throw new ArithmeticException("You are not eligible for internship")
else println("You are eligible for internship")
}
// Main method
def main(args: Array[String])
{
validate(22)
}
}
Producción :
You are eligible for internship
Excepciones de prueba y captura:
Scala
// Scala program of try-catch Exception
import java.io.IOException
// Creating object
object GFG
{
// Main method
def main(args:Array[String])
{
try
{
var N = 5/0
}
catch
{
// Catch block contain cases.
case i: IOException =>
{
println("IOException occurred.")
}
case a : ArithmeticException =>
{
println("Arithmetic Exception occurred.")
}
}
}
}
Producción :
Arithmetic Exception occurred.
El manejo de archivos es una forma de almacenar la información obtenida en un archivo. Scala proporciona paquetes desde los que podemos crear, abrir, leer y escribir los archivos. Para escribir en un archivo en Scala, tomamos prestado java.io._ de Java porque no tenemos una clase para escribir en un archivo, en la biblioteca estándar de Scala. También podríamos importar java.io.File y java.io.PrintWriter.
- Creando un nuevo archivo:
- java.io.File define clases e interfaces para los archivos de acceso, sistemas de archivos y atributos de JVM.
- File(String pathname) convierte la string de parámetros en un nombre de ruta abstracto, creando una nueva instancia de archivo.
- Escribir en el archivo:
java.io.PrintWriter incluye todos los métodos de impresión incluidos en PrintStream.
A continuación se muestra la implementación para crear un nuevo archivo y escribir en él.
Scala
// Scala File handling program
import java.io.File
import java.io.PrintWriter
// Creating object
object Geeks
{
// Main method
def main(args:Array[String])
{
// Creating a file
val file_Object = new File("abc.txt" )
// Passing reference of file to the printwriter
val print_Writer = new PrintWriter(file_Object)
// Writing to the file
print_Writer.write("Hello, This is Geeks For Geeks")
// Closing printwriter
print_Writer.close()
}
}
- Lectura de un archivo: a
continuación se muestra el ejemplo para leer un archivo.
Scala
// Scala File handling program
import scala.io.Source
// Creating object
object GeeksScala
{
// Main method
def main(args : Array[String])
{
// file name
val fname = "abc.txt"
// creates iterable representation
// of the source file
val fSource = Source.fromFile(fname)
while (fSource.hasNext)
{
println(fSource.next)
}
// closing file
fSource.close()
}
}
Para obtener más información sobre los diferentes manejos de archivos, consulte Manejo de archivos en Scala
Una lista es una colección que contiene datos inmutables. List representa una lista enlazada en Scala. La clase Scala List contiene una lista lineal secuenciada de elementos. Las listas son inmutables, mientras que las arrays son mutables en Scala. En una lista de Scala, cada elemento debe ser del mismo tipo. list se define en el paquete scala.collection.immutable.
Sintaxis:
val variable_name: List[type] = List(item1, item2, item3) or val variable_name = List(item1, item2, item3)
Crear e inicializar Scala List
Ejemplo:
Scala
// Scala program to print immutable lists
import scala.collection.immutable._
// Creating object
object GFG
{
// Main method
def main(args:Array[String])
{
// Creating and initializing immutable lists
val mylist1: List[String] = List("Geeks", "GFG",
"GeeksforGeeks", "Geek123")
val mylist2 = List("C", "C#", "Java", "Scala",
"PHP", "Ruby")
// Display the value of mylist1
println("List 1:")
println(mylist1)
// Display the value of mylist2 using for loop
println("\nList 2:")
for(mylist<-mylist2)
{
println(mylist)
}
}
}
Producción :
List 1: List(Geeks, GFG, GeeksforGeeks, Geek123) List 2: C C# Java Scala PHP Ruby
Para obtener más información sobre List, consulte List en Scala .
El mapa es una colección de pares clave-valor. En otras palabras, es similar al diccionario. Las claves siempre son únicas, mientras que los valores no necesitan ser únicos. Para usar el mapa mutable, debemos importar la clase scala.collection.mutable.Map explícitamente.
Crear un mapa y acceder al valor
Ejemplo:
Scala
// Scala map program of
// Accessing Values Using Keys
// Creating object
object GFG
{
// Main method
def main(args:Array[String])
{
val mapIm = Map("Ajay" -> 30,
"Bhavesh" -> 20,
"Charlie" -> 50)
// Accessing score of Ajay
val ajay = mapIm("Ajay")
println(ajay)
}
}
Producción :
30
Para saber más sobre Mapa, consulte Mapa en Scala .
Un iterador es una forma de acceder a los elementos de una colección uno por uno. Se parece a una colección en términos de sintaxis pero funciona de manera diferente en términos de funcionalidad. Para acceder a los elementos podemos hacer uso de hasNext() para verificar si hay elementos disponibles y next() para imprimir el siguiente elemento.
Sintaxis:
val v = Iterator(5, 1, 2, 3, 6, 4) //checking for availability of next element while(v.hasNext) //printing the element println(v.next)
Ejemplo :
Scala
//Scala iterator program
//for defining iterator
//Creating object
object GFG
{
// Main method
def main(args:Array[String])
{
val v = Array(5, 1, 2, 3, 6, 4)
//val v = List(5, 1, 2, 3, 6, 4)
// defining an iterator
// for a collection
val i = v.iterator
while (i.hasNext)
print(i.next + " ")
}
}
Producción:
5 1 2 3 6 4
Para obtener más información sobre la tupla, consulte Iteradores en Scala .
Un conjunto es una colección que solo contiene artículos únicos. La unicidad de un conjunto se define por el método == del tipo que contiene el conjunto. Si intenta agregar un elemento duplicado en el conjunto, descarte tranquilamente su solicitud.
Sintaxis:
// Immutable set val variable_name: Set[type] = Set(item1, item2, item3) or val variable_name = Set(item1, item2, item3) // Mutable Set var variable_name: Set[type] = Set(item1, item2, item3) or var variable_name = Set(item1, item2, item3)
Creación e inicialización de un conjunto inmutable
Ejemplo:
Scala
// Scala program to illustrate the
// use of immutable set
import scala.collection.immutable._
object Main
{
def main(args: Array[String])
{
// Creating and initializing immutable sets
val myset1: Set[String] = Set("Geeks", "GFG",
"GeeksforGeeks", "Geek123")
val myset2 = Set("C", "C#", "Java", "Scala",
"PHP", "Ruby")
// Display the value of myset1
println("Set 1:")
println(myset1)
// Display the value of myset2 using for loop
println("\nSet 2:")
for(myset<-myset2)
{
println(myset)
}
}
}
Producción :
Set 1: Set(Geeks, GFG, GeeksforGeeks, Geek123) Set 2: Scala C# Ruby PHP C Java
Creación e inicialización de un conjunto mutable
Ejemplo:
Scala
// Scala program to illustrate the
// use of mutable set
import scala.collection.immutable._
object Main
{
def main(args: Array[String])
{
// Creating and initializing mutable sets
var myset1: Set[String] = Set("Geeks", "GFG",
"GeeksforGeeks", "Geek123")
var myset2 = Set(10, 100, 1000, 10000, 100000)
// Display the value of myset1
println("Set 1:")
println(myset1)
// Display the value of myset2
// using a foreach loop
println("\nSet 2:")
myset2.foreach((item:Int)=>println(item))
}
}
Producción :
Set 1: Set(Geeks, GFG, GeeksforGeeks, Geek123) Set 2: 10 100000 10000 1000 100
Para saber más sobre Set, consulte Set en Scala | Set-1 y Set en Scala | Conjunto-2 .
Tuple es una colección de elementos. Las tuplas son estructuras de datos heterogéneas, es decir, pueden almacenar elementos de diferentes tipos de datos. Una tupla es inmutable, a diferencia de una array en scala que es mutable.
Crear una tupla y acceder a un elemento
Ejemplo:
Scala
// Scala program to access
// element using underscore method
// Creating object
object gfg
{
// Main method
def main(args: Array[String])
{
var name = (15, "chandan", true)
println(name._1) // print 1st element
println(name._2) // print 2st element
println(name._3) // print 3st element
}
}
Producción :
15 chandan true
Para saber más sobre la tupla, consulte la tupla en Scala .
Publicación traducida automáticamente
Artículo escrito por DivyaPareek y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA