Cómo implementar Scala arriba, al lado y toString
Introducción a la práctica de sintaxis básica de Scala
Primero, consulte las guías relevantes, descargue e instale Java y Scala respectivamente en Linux, y luego configure las variables de entorno de Java y Scala. Una vez completada la instalación, puede escribir scala en la terminal para ingresar a la línea de comando de Scala, como se muestra a continuación:
root@Master:~# scala
Bienvenido a Scala versión 2.10 .4 (VM de servidor Java HotSpot (TM) de 64 bits, Java 1.8.0_66).
Escriba una expresión para evaluarla.
Escribe :help para más información.
Prueba simple
scalagt; 1 2
res0: Int = 3
scalagt; >res1: Doble = 3.0
scalagt; 3*res1
res2: Doble = 9.0
// Presione la tecla Tab, el comando se completará automáticamente
scalagt; res2.to
toByte toChar toDouble toFloat toInt toLong toShort toString
Variables
var declara variables mutables; variables.
val declara una variable inmutable que no espera que se cambien los datos; los datos dentro del RDD son inmutables, por lo que val se usa generalmente en Spark.
// A continuación se declara un resultado variable inmutable y el valor del resultado no se puede cambiar.
scalagt; val result=2 10
resultado: Int = 12
// Si cambia el valor del resultado, se generará un error, como se muestra a continuación:
scalagt; resultado=13
lt; consolegt;: 8: error: reasignación a val
resultado=13
//var Declarar variable:
scalagt; var name="Spark"
nombre: String = Spark
scalagt.name="Scala" // Puedes cambiar la variable El valor de nombre
nombre: String = Scala
scalagt; nombre //El valor de nombre ahora es Scala
res4: String = Scala
/val declara una variable inmutable<
/age declara una variable inmutable de tipo Int
val age: Int = 0
edad: Int = 0
//Declarado como tipo String
scalagt; val nombre: String = null
nombre: String = null
en una línea de código Declarar múltiples variables
scalagt; val edad1, edad2, edad3=0
edad1: Int = 0
edad2: Int = 0
age3: Int = 0
Operaciones básicas de conversión automática
Scala completa la conversión automática de tipos de datos básicos por sí solo. toString
res5: String = 10
scalagt; 0.to(5)
res6: scala.collection.immutable.Range.Inclusive = Range(0 , 1, 2, 3, 4, 5)
Danos un conjunto inmutable y el resultado es: 0 a 5, ¡así que todo en Scala es un objeto!
Conversión implícita de Scala:
Cuando el tipo en sí no tiene un método que no existe pero que debe llamarse, la conversión implícita se activa automáticamente internamente. En el ejemplo anterior, Int en sí no tiene un método to-like, y el motor Scala lo convertirá implícita y automáticamente a RichInt internamente, al igual que la llamada 0.to(5) anterior. Solo el tipo de objeto RichInt tiene un to. -como método.
scalagt; 1 1
res7: Int = 2
//Debido a que todo es un objeto en Scala, el ejemplo anterior se puede escribir de la siguiente manera:
scalagt; 1. (1)
res9: Double = 2.0
Este ejemplo es en realidad una conversión implícita a Int.
Scala No, ---- operación:
scalagt; var edad=10
edad: Int = 10
// Scala No, ---- operación :
scalagt; edad
lt.consolegt :9: error: el valor no es miembro de Int
edad
^
// Pero la operación se puede implementar de la siguiente manera:
scalagt;age =1
scalagt age
res12. : Int = 11
Buscar máximo, mínimo
scalagt; min(20, 4)
lt;: 8: error: no encontrado: valor min
min(20, 4)
^
Este ejemplo es incorrecto porque no importa la biblioteca.
scalagt; import scala.math._ //importar biblioteca matemática
import scala.math._
scalagt; p>
scalagt; p>
res14: Int = 4
Método de implementación de construcción de fábrica de aplicación
En Spark, una gran cantidad de instancias se construyen utilizando el método de aplicación. .
scalagt; Array(1, 2, 3, 4)
res15: Array[Int] = Array(1, 2, 3, 4)
scalagt; val matriz=Array(1, 2, 3, 4)
matriz: Matriz[Int] = Matriz(1, 2, 3, 4)
//matriz es Una variable de matriz que declara un tipo entero en realidad llama automáticamente al método Array.apply internamente, lo que equivale a:
scalagt;val array = Array.apply(1, 2, 3, 4)
array.: Array[Int] = Array(1, 2, 3, 4)
Control condicional, bucle
//ejemplo de expresión if:
scalagt; if(agegt;=18) "Adulto" else "Niño"
res16： String = Adulto
val result = if(agegt;=18) " adulto" else "niño"
resultado: String = adulto
scalagt; resultado
res17: String = adulto
scalagt; val resultado = if(agegt;=18){
| "adulto"
| buffered=10
| buffered
|
Lo anterior es un bloque de código, seguido de un búfer de valor de retorno, y el valor de retorno del bloque de código es la última línea.
Imprime el valor
scalagt; println("Spark") // Genera una línea de cadena con carácter de nueva línea
Spark
scalagt; println("\nSpark")//Envuelve y genera una línea de cadena con un carácter de nueva línea. \n es un carácter de nueva línea.
Spark
scalagt; print("Spark") // Genera una línea de cadena sin saltos de línea
Spark
scalagt;
Rellenar el marcador de posición
scalagt; printf("s es el futuro del marco de big data!", "Spark") //s es el marcador de posición
Spark es el futuro del marco de big data
Leer contenido
readLine se usa para leer la entrada
scalagt; readLine // En este momento, escriba Scala y luego Enter
res28.String = Scala
scalagt; res28
res29: String = Scala
Explicación adicional, readLine es un método Si no hay parámetros, este método se puede usar sin paréntesis, entonces readLine () tiene el mismo efecto que readLine.
Bucle
//Declarar una variable con valor inicial 100
scalagt; var element=100
elemento: Int = 100
// ejemplo de bucle while:
scalagt; while(elementgt;90){
| println(elemento)
| = 1
| }
100
99
98
97
96
95
94
93
92
91
scalagt; 0 al elemento
res32: scala.collection.immutable.Range.Inclusive = Range(0, 1)Inclusive = Range(0, 1, 2, 3, 4, 5, 6, 7 Inclusive = Range (0, 1, 2, 3, 4, 5, 6, 7), 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90)
//para bucle e impresión
scalagt; for (ilt; -80 al elemento) println(i)
80
81
82
83
84
85
86
87
88
89
90
// Bucle y agregue juicio condicional
scalagt; for(ilt;-0 al elemento if i2==0) print(i " ")
0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48 50 52 54 56 58 60 62 64 66 68 70 72 74 76 78 8 0 82 84 86 88 90
//salida de bucle for e interrupción
scalagt; import scala.util.control.>
scalagt; def f1: Any = {
| para(i lt; -1 a 10){
| si(i==n) devuelve i
| p >
| }
| }
f1： Cualquier
scalagt;
1
2
3
4
res1: Cualquiera = 5
Explique el bloque de código anterior, def define una función, f1 es una función.
Dos: práctica introductoria a la función Scala
Ejemplo de función
La función se define usando la palabra clave def y hay un valor de retorno al final del cuerpo de la función. .
//Declara una función f3 con dos parámetros: param1 es de tipo String y param2 es de tipo Int. El valor predeterminado de param2 es 30. Dado que es el valor predeterminado, no es necesario llamar a param2.
scalagt; def f3(param1: Cadena, param2: Int=30) = param1 param2
f3: (param1: Cadena, param2: Int)Cadena
// Llame a la función f3, pase el valor Spark del primer parámetro param1, no pase el segundo parámetro, el valor predeterminado es 30.
scalagt("Spark")
res4: String = Spark30
// Llamada usando parámetros con nombre, es decir, al llamar a la función, se muestran los nombres de los parámetros especificados y los parámetros no se pasan en orden.
scalagt; f3(param2=100, param1="Scala")
res5: string = Scala100
//Parámetros de longitud variable, definidos Una suma función que toma el número de parámetro como parámetro, es decir, el número de variables Int pasadas es variable. En el cuerpo de la función, todas las variables Int pasadas se recorrerán, acumularán y sumarán, y finalmente se devolverá el resultado.
scalagt; def suma(números: Int*)={var resultado=0; for(elementlt;-números) resultado =elemento}
suma: (números: Int *)Int
scalagt; suma(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
res1: Int = 55
Abajo El ejemplo es una sintaxis muy clásica
scalagt; sum(1 a 10: _*) // _* significa extraer cada elemento y pasarlo como un parámetro de longitud variable
res3 : Int = 55
Programa
Una función sin valor de retorno es un programa.
// Esta es una función
scalagt; def mañana(content: String) = "Bueno" contenido
mañana: (content: String)String
// Este es un proceso
scalagt; def mañana(content: String) { println( "Bueno" contenido)}
morning: (content: String) ) )Unidad
scalagt; def mañana(contenido: Cadena) { println(Contenido "bueno")}
mañana: (contenido: Cadena)Unidad
// Este es un proceso de declaración obligatorio
scalagt.def Morning(content: String): Unit = "Good" content
morning: (content: String)Unit
Declarar tipos diferidos
scalagt; import scala.io._ //importar biblioteca de referencia
importar scala.io.Source._
/ Declara el contenido de una variable de tipo diferido y abre un archivo que no existe.
scalagt; lazy val content = fromFile("/root/txt")
contenido: scala.io.BufferedSource = lt;
Arriba de allí; No hay error cuando se ejecuta el ejemplo, lo que indica que la variable de contenido no se ejecuta.
// Si elimina la palabra clave diferida, obtendrá un error que indica que el archivo no existe.
scalagt; val content = fromFile("/root/txt")
java.io.FileNotFoundException:/root/txt (No existe tal archivo o directorio)
en java.io.FileInputStream.open0(Método nativo)
en java.io.FileInputStream.open(FileInputStream.java:195)
en java.io.FileInputStream. lt;initgt;(FileInputStream.java:138)
Las operaciones que consumen mucho tiempo son más comunes en grandes sistemas distribuidos. Declare variables de tipo LAZY y ejecútelas solo cuando sea necesario.
Excepción
// Primero importe el paquete de referencia relevante
scalagt; import java.io._
import java.io. _
scalagt;
// El ejemplo abre un archivo existente y usa try...catch para detectar la excepción
scalagt;
| val content = fromFile("/root/.bashrc").mkString
}catch{
//case es una función de sesgo
| case _: FileNotFoundException =gt; println("¡Oh, archivo no encontrado!")
}finalmente{
| >
| }
¡Ok! p>scalagt；
/Muestra abriendo un archivo que no existe, usando try...catch para detectar excepciones
scalagt; prueba{
| val contenido = fromFile("/root/.bashrc111"). mkString
}catch{
| /case Es una función parcial
| case _: FileNotFoundException =gt; println("¡Oh, archivo no encontrado!")
}finalmente{
| println( "¡Ok!")
| }
¡Oh, archivo no encontrado!
¡Ok!
Tres ejemplos prácticos del uso de Array, Map y Tuple en Scala
Array
/Declarar variable arr es un array de tipo Array entero, que contiene 5 elementos.
scalagt; val arr= new Array[Int][5)
arr: Array[Int] = Array(0, 0, 0, 0, 0, 0)
/Obtener el tercer elemento
scalagt; arr(2)
res15.Int = 0
/ Modificar el tercer elemento
scalagt; arr(2)=8
/ Accede nuevamente a la matriz arr, puedes ver que el valor del tercer elemento pasa a ser 8.
scalagt; arr
res17: Array[Int] = Array(0, 0, 8, 0, 0)
Explicación adicional, recién declarado arr Cuando una variable de matriz se declara como val, una variable inmutable simplemente significa que la dirección de arr es inmutable, pero los elementos dentro de la matriz aún se pueden cambiar.
// En Spark, es más común crear matrices directamente basadas en nombres de clases
scalagt; val arr1 = Array("Scala", "Spark")
arr1: Array[String] = Array(Scala, Spark)
Este ejemplo declara arr1 como una variable de matriz, pero no utiliza la nueva palabra clave ni especifica el tipo String De forma predeterminada, el sistema. automáticamente El tipo de elemento se deduce a String. Al agregar elementos a la matriz arr1, la siguiente escritura será un error, por ejemplo:
scalagt; arr1(2)="Hadoop"
java.lang.ArrayIndexOutOfBoundsException: 2
en .lt;initgt;(lt;consolegt;:16)
en .lt;clinitgt;(lt;consolegt;)
... .. .
Si necesita agregar elementos a una matriz, debe usar el tipo ArrayBuffer.
ArrayBuffer
// Primero importa la biblioteca
scalagt; import scala.collection.mutable.ArrayBuffer
import scala.collection. mutable .ArrayBuffer
// Si necesita agregar elementos a una matriz, debe usar el tipo ArrayBuffer.
ArrayBuffer
//Definir una variable arrbuffer de tipo ArrayBuffer
scalagt; val arrbuffer=ArrayBuffer[Int]()
arrbuffer: scala.collection.mutable. ArrayBuffer[Int] = ArrayBuffer()
//agrega un elemento a arrbuffer con valor 10
scalagt; arrbuffer = 10
res23: arrbuffer.type = ArrayBuffer(10)
//agrega múltiples elementos a arrbuffer
scalagt; arrbuffer = (11, 1, 3, 5)
res25: arrbuffer.type = ArrayBuffer(10, 11, 1, 3, 5)
// Ver el contenido de arrbuffer
scalagt; arrbuffer
res26: scala.collection. mutable .ArrayBuffer[Int] = ArrayBuffer(10, 11, 1, 3, 5) //Truncar 3 elementos después de arrbuffer
scalagt; arrbuffer.trimEnd(3)
/ / Verifique el contenido de arrbuffer nuevamente y descubra que los elementos 2, 3 y 4 están truncados: insert (5, 100)
Verifique el contenido de arrbuffer
scalagt; >
res32: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(10, 11, 1. 3, 5, 100, 1)
//Inserta múltiples elementos en la segunda posición: 200, 300, 400
scalagt; arrbuffer.insert(2, 200, 300, 400)
//Ver el contenido de arrbuffer
scalagt.
res34: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(10.mutable.ArrayBuffer[Int] = ArrayBuffer(10, 11, 200, 300, 400, 1, 3, 5, 100 , 1)
Eliminar de arrbuffer la tercera posición
scalagt; arrbuffer.remove(3)
res35: Int = 300 // Valor eliminado Es 300
// Mirando nuevamente el contenido de arrbuffer, encontré que el elemento 300 en la tercera posición ya no existe.
scalagt; arrbuffer
res36: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(10, 11, 200, 400, 1, 3, 5, 100, 1)
// Elimina el valor 300 comenzando desde la 2ª posición, es decir, 3 elementos, de arrbuffer. Por ejemplo: 200, 400, 1
scalagt; arrbuffer.remove(2, 3)
// Verifica el contenido de arrbuffer nuevamente, puedes ver tres elementos: 200, 400 , 1 ya no está. En este momento, arr2 es una matriz inmutable
scalagt; val arr2 = arrbuffer.toArray
arr2.Array[Int] = Array 10