Red de conocimiento informático - Material del sitio web - Cómo implementar Scala arriba, al lado y toString

Cómo implementar Scala arriba, al lado y toString

Spark también se basa en JVM. Usamos JVM para construir sistemas distribuidos sin necesariamente usar el lenguaje Java. El middleware de mensajes como Spark y KAFKA está escrito en Scala. Aprender Scala es la clave para dominar Spark.

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