Aviso: Este artículo es un artículo blogger original, siga el CC 4.0 BY-SA acuerdo de derecho de autor, reproduce, por favor adjuntar el enlace de la fuente original y esta declaración.
Directorio artículo
1. declaración de variables
las variables Scala dividen en dos tipos: Val y var.
val variables es similar a la de Java final, una vez inicializado no puede ser re-asignado.
var puede ser reasignado.
Cuando la declaración de variables, se puede especificar el tipo, sino que también no se especifica el tipo (esta vez lo hará automáticamente inferir el tipo)
// val声明变量
val str01:String = "Hello World"
val str02 = "str02"
// str02 = "str00" 会编译错误
// var声明变量
var str03 = "str03"
str03 = "aaa" // 不会编译错误
Scala programa viene con un alcance variable en la instrucción, los apoyos generalmente introduce un nuevo ámbito.
Sobre el alcance, es la diferencia entre Scala y Java, Java no permite el uso de una variable con el mismo nombre fuera del alcance de la incorporada en el ámbito de aplicación, pero las variables incluidas en el alcance Scala bloquearán el mismo nombre fuera del alcance de las variables, las variables no son visibles fuera del alcance del mismo nombre construida en su alcance.
2. Tipos de datos
2.1 función del tipo de
Java y más consistente.
- Byte: 8 bits con signo de dos números enteros del complemento
- Breve: 16 bits con signo de dos números enteros del complemento
- Int: 32 bits con signo de dos números enteros del complemento
- Largo: 64 bits con signo de dos números enteros del complemento
- Char: 16 bits sin signo de caracteres Unicode
- Float: bits IEEE en coma flotante de precisión simple de 32 754
- Doble: 64 bits IEEE 754 de doble precisión en coma flotante
- Booleano: true 或 falsa
- La secuencia: secuencia de Char
2.2 literales
- Literal entero
Int, literales enteros largos, cortos, Byte, hay dos formas: decimal y hexadecimal, distinto comienzo expresó banda diferente. Hex: con 0x o 0X, puede comprender 0 a 9 y minúsculas o mayúsculas A ~ F.
Si el número entero literal terminado con l o L, es de tipo long, de lo contrario Int. - Flotante literal
por un número decimal, un punto decimal opcional, y una posterior opcional E o E a partir de la composición de índice. Por ejemplo 1.2345e2.
Pagado el literal flotador para poner fin a F o F, entonces es el tipo flotador, de lo contrario un doble. Doble o puede terminar D d, pero esto es opcional. - literales de caracteres
de cualquier comillas simples caracteres Unicode y componentes intermedios. Además de mostrar los caracteres dados originales, caracteres Unicode pueden ser representados, es particularmente \ u más cuatro número hexadecimal correspondiente al código de Unicode, por ejemplo: val d = '\ u0041' . - Cadena literal
paquete carácter proporcionado por la composición comillas dobles.
Si no desea escribir una gran cantidad de cadenas de secuencias de escape o cruzar la línea, puede utilizar tres comillas dobles para empezar y terminar con tres comillas dobles para representar la cadena nativa dentro de una cadena nativa puede contener cualquier carácter, incluyendo los saltos de línea, simples o dobles citas y otros caracteres especiales.
var a = """ Welcome to here.
I am very glad to see you."""
println(a)
打印结果：
Welcome to here.
I am very glad to see you.
问题在于：字符串第二行前面的空格被包含进去，为了解决这个问题，可以每行开始加一个管道符|，然后对字符串调用stripMargin方法，如下。
var a = """Welcome to here.
|I am very glad to see you.""".stripMargin
println(a)
打印结果：
Welcome to here.
I am very glad to see you.
2.3 cadena de interpolación
- s interpolador: variable de proceso
- interpolador prima: caracteres especiales mango
- f interpolador: expresiones incrustadas para agregar la instrucción de estilo printf después de la instrucción en la expresión, para iniciar un signo de porcentaje%
val name = "Jason"
println(s"Hello, $name") // Hello, Jason
println(s"The answer is ${6*7}") // The answer is 42
println(raw"Hello\\\\World") // Hello\\\\World
println(f"${Math.PI}%.5f") // 3.14159
3. operador
3.1 Tradicionalmente operador entiende en Scala
Scala en realidad no operador en el sentido tradicional. Del mismo modo +, -, *, / así que los personajes pueden ser utilizados como el nombre del método. Por ejemplo, 1 + 2 es en realidad llamado método de objeto llama Int + de la 2 como un parámetro 1, es decir, 1. + (2), una pluralidad Int + sobrecargado métodos, puede recibir diferentes parámetros son escriba.
Utilice entero entre /, retiene sólo la parte entera del resultado, y no será redondeado.
- Los operadores aritméticos: + - * /%
- De relación, y operadores lógicos:> <> = <=!
- Los operadores lógicos: && o Y, o || |. && y || están en circuito corto, no será evaluado en el lado derecho de la izquierda ha sido resultado determinado de la expresión de la caja.
- operadores de bits: & | ^ ~ >> (a la derecha, el valor del lado izquierdo del bit más significativo (bit de signo) está vacío) >>> (desplazamiento a la derecha sin signo, relleno automático 0) << (desplazamiento a la izquierda, relleno automático 0)
- Objeto de la igualdad:! == =
println(1==1.0) //true, diferente de la Scala de Java ==, Scala devuelve verdadero, siempre y cuando el contenido es consistente
Los operadores de 3,2 Scala
El método de representación Scala operador no se limita a otros idiomas como el operador se ve, cualquier método puede ser usado en notación de operadores. Por ejemplo la clase indexOf cadena tiene un método, para que pueda utilizar
val str = "Hello World"
println(str indexOf 'e') // 1
println(str indexOf ('o',5)) // 7
3.3 prefijo, infijo, operadores de sufijo
Algunos ejemplos citados anteriormente son operadores infijos. Prefijo de nombre de método de notación tiene que ser colocado en frente de la invocación del método objeto, lo contrario sufijo
operador de prefijo se llama en realidad método "unary_" plus operador, por ejemplo, en realidad -2,0 (2,0) .unary_-. La única puede ser utilizado como un operador de prefijo es +, - ,! - y
// 前缀
val a = (2.0).unary_-
// 后缀
val b = "Hello World" toLowerCase()
println(a) // -2.0
println(b) // hello world
4. Estructura de Control
Scala Sólo unos pocos integrado en la estructura de control, incluyendo: si, mientras que, do ... while , para, intentar, fósforo y llamadas a funciones.
Todas las estructuras de control Scala regresan algún valor como el resultado.
4.1 si
Los resultados pueden ser devueltos si la específica
4.2, mientras que / do ... while
while, do ... mientras que el retorno al valor unitario partícipes ()
4.3 para
- puede añadir filtros para la expresión, la expresión entre paréntesis es la si cláusula, se puede añadir una pluralidad de filtros.
val filesHere = new File("D:\\MyProject").listFiles
// 单个过滤器
for(file <- filesHere if !file.getName.endsWith(".scala"))
println(file)
// 多个过滤器
for(file <- filesHere
if file.isFile
if !file.getName.endsWith(".scala"))
println(file)
- iteración anidada
val fileHere = new File(".").listFiles()
def fileLines(file: File) = scala.io.Source.fromFile(file).getLines().toList
def grep(pattern: String) =
for (
file <- fileHere
if file.getName.endsWith(".scala");
line <- fileLines(file);
trimLine = line.trim
if trimLine.matches(pattern)
) println(file + ":" + trimLine)
grep(".*gcd.*")
- Por palabra clave
yielddevuelve una lista de
formato:for 子句 yield 代码体
val res = for (i <- 0 to 3) yield {
i * i
}
println(res.mkString(",")) // 0,1,4,9
