3、Scala 基础语法
3.1、Hello Scala
package com.mazh.scala.helloworld
/**
* 作者： 李涛： https://blog.csdn.net/qq_42246689
*/
object HelloWorld { // 作用类似于 J ava 的 main 方法
def main(args: Array[String]): Unit = {
println("hello world")
} }关于 HelloWorld 程序：Scala 和 Java 的对比不同处
1、文件后缀名
2、编译和运行方式
3、类的声明
4、main 方法的声明
5、分号
3.2、变量定义
package com.mazh.scala.core
/**
* 作者： 李涛： https://blog.csdn.net/qq_42246689
*/
object VariableDemo {
def main(args: Array[String]) {
// 使用 val
定义的变量值是不可变的，相当于 java
里用 final
修饰的变量
val i = 1
// 使用 var
定义的变量是可变得，在 Scala
中鼓励使用 val
var s = "hello"
//Scala
编译器会自动推断变量的类型，必要的时候可以指定类型
// 变量名在前，类型在后 val str: String = "spark"
}
}总结：
1）数据类型可以指定，也可以不指定，如果不指定，那么就会进行数据类型的自动推断。
2）如果指定数据类型，数据类型的执行方式是在变量名后面写一个冒号，然后写上数据类 型。
3）我们的 scala 里面变量的修饰符一共有两个，一个是 var，一个是 val 如果是 var 修饰的变量，那么这个变量的值是可以修改的 如果是 val 修饰的变量，那么这个变量的值是不可以修改的
懒加载：两个例子
scala> import scala.io.Source import scala.io.Source
scala> lazy val file = Source.fromFile("/home/hadoop/student.txt") file: scala.io.BufferedSource = <lazy>
scala> file res2: scala.io.BufferedSource = non-empty iterator
scala> for (f <- file.getLines) println(f)
95002,刘晨,女,19,IS
95017,王风娟,女,18,IS
95018,王一,女,19,IS
95013,冯伟,男,21,CS
95014,王小丽,女,19,CS
95019,邢小丽,女,19,IS
95020,赵钱,男,21,IS
95003,王敏,女,22,MA
95004,张立,男,19,IS
95012,孙花,女,20,CS
95010,孔小涛,男,19,CS
95005,刘刚,男,18,MA
95006,孙庆,男,23,CS
95007,易思玲,女,19,MA
95008,李娜,女,18,CS
95021,周二,男,17,MA
95022,郑明,男,20,MA
95001,李勇,男,20,CS
95011,包小柏,男,18,MA
95009,梦圆圆,女,18,MA
95015,王君,男,18,MA 
3.3、数据类型
3.3.1、数据类型概述
Scala 和 Java 一样，有 7 种数值类型 Byte、Char、Short、Int、Long、Float 和 Double（无包 装类型）和一个 Boolean 类型，再加上常用的 String 类型
数据类型：http://www.runoob.com/scala/scala-data-types.html
注意：scala 里面没有基本数据类型和包装类型之说。
如果大家非要说的话，那么大家都可以认为都有的类型的类型都是包装类型。
package com.mazh.scala.core
/**
* 作者： 李涛： https://blog.csdn.net/qq_42246689
*/
object TypeDemo {
def main(args: Array[String]): Unit = {
val var_int = 1
val var_double = 3.33
val var_float = 2.4F
val var_char = 'A'
val var_bool = true
val var_16 = 0x29
val var_string = "aa"
val var_string1 = "\"huangbo\""
val var_string2 = """hello\thello\na\t\\"""
println (var_string2)
}
} 
要点：
1、 Any 是所有类的父类，包括值类型 AnyVal，和引用类型 AnyRef
2、 AnyVal 是所有值类型的父类，包括 Int，Double，Boolean，Unit 等等
3、 AnyRef 是所有引用类型的父类，包括 Null
4、 Null 是所有引用类型的子类
5、 Nothing 是所有类的子类
6、 Unit 类型只有一个实例，是()，相当于 java 中的 void，没有任何的实质意义
7、 Null 也只有一个实例，是 null，相当于 java 中的 null，能赋值给任何引用类型变量，不 能赋值给值类型变量
3.3.2、Scala 基本类型操作
算术操作：+ - * / % // 关系运算：> >= < <= == != 逻辑运算：&& || ! 位运算： & | ^ ~ >> << >>> 对象比较：1==1 1==1.0 "huangbo" == "huangbo" ne eq
特别注意：ne eq equals ==
3.4、编码规范
1、分号：在 scala 编码中，不强制在代码末尾加分号，但是如果有多句代码写在同一行，那
么必须使用分号进行隔开
2、注释：在 scala 编程中，注释的方式和 java 中注释方式一样，原则：少而精
3、关键字：关注新关键字：yield, match, object, def, implicit, trait, sealed, var/val
3.5、流程控制--条件表达式 if
Scala 的的条件表达式比较简洁，例如：
package com.mazh.scala.core
/**
* 作者： 李涛： https://blog.csdn.net/qq_42244689
*/
object ConditionDemo {
def main(args: Array[String]) {
val x = 1
// 判断 x
的值，将结果赋给 y
val y = if (x > 0) 1 else -1
// 打印 y
的值
println(y)
// 支持混合类型表达式 val z = if (x > 1) 1 else "error"
// 打印 z
的值
println(z)
// 如果缺失 else ，相当于 if (x > 2) 1 else ()
val m = if (x > 2) 1
println(m)
// 在 scala中每个表达式都有值， scala中有个 Unit类，写做 (), 相当于 Java中的 void
val n = if (x > 2) 1 else ()
println(n)
//if
和 else if
val k = if (x < 0) 0
else if (x >= 1) 1 else -1
println(k)
}
} 总结：
1）if 条件表达式它是有返回值的，返回值是多个分支的返回结果的共同父类
2）返回值会根据条件表达式的情况会进行自动的数据类型的推断（返回的是多个分支的共 同父类）
3.6、块表达式
package com.mazh.scala.core
/**
* 作者： 李涛： https://blog.csdn.net/qq_42246689
*/
object BlockExpresstionDemo {
def main(args: Array[String]) {
val x = 0
// 在 scala
中 {} 中课包含一系列表达式， 块中最后一个表达式的值就是块的值
// 下面就是一个块表达式 val result = {
if (x < 0){
-1
} else if(x >= 1) {
1
} else {
"error"
}
}
//result
的值就是块表达式的结果
println(result)
}
} 总结：就算是赋值表达式，也是有返回值的。是空，是 Unit
3.7、流程控制--循环 for 和 while
在 scala 中有 for 循环和 while 循环，用 for 循环比较多
for 循环语法结构：for (i <- 表达式/数组/集合)
package com.mazh.scala.core
/**
* 作者： 李涛： https://blog.csdn.net/qq_42246689
*/
object ForDemo {
def main(args: Array[String]) {
//for(i <- 表达式 ), 表达式 1 to 10
返回一个 Range （区间）
// 每次循环将区间中的一个值赋给 i
for (i <- 1 to 10)
println(i)
//for(i <- 数组 )
val arr = Array("a", "b", "c")
for (i <- arr)
println(i)
// 倒序打印 for (str <- arr.reverse){
println(str)
}
// 使用数组下标的方式进行打印 for (i <- 0 to arr.length - 1){
println(arr(i))
}
for (i <- 0 until arr.length)
println(arr(i))
println("-----------------")
for (i <- 0 until (arr.length, 2))
println(arr(i))
// 高级 for循环
// 每个生成器都可以带一个条件，注意： if前面没有分号
for(i <- 1 to 3; j <- 1 to 3 if i == j)
println((10 * i + j) + " ")
println()
//for推导式：如果 for循环的循环体以 yield开始，则该循环会构建出一个集合
// 每次迭代生成集合中的一个值 val v = for (i <- 1 to 10) yield i * 10
println(v)
}
}总结：
1、在 scala 里面没有运算符，都有的符号其实都是方法。
2、在 scala 里面没有 ++ -- 的用法
3、for( i <- 表达式/数组/集合)
4、在 for 循环里面我们是可以添加 if 表达式
5、有两个特殊表达式需要了解： To 1 to 3 1 2 3 To 1 to (3,2) 1 3 Until 1 until 3 12
6、如果在使用 for 循环的时候，for 循环的时候我们需要获取，我们可以是使用 yield 关键字
While 循环测试例子：
package com.mazh.scala.core
/**
* 作者： 李涛： https://blog.csdn.net/qq_42246689
*/
object WhileDemo {
def main(args: Array[String]) {
var n = 10;
while (n > 0) {
println(n)
n -= 1
}
}
}总结：
1）while 使用跟 java 一模一样
2）注意点：在 scala 里面不支持 i++ i-- 等操作统一写成 i+=1 i-=1 v
3.8、方法和函数
Scala 中的+ - * / %等操作符的作用与 Java 一样，位操作符 & | ^ >> <<也一样。
只是有一点特别的：这些操作符实际上是方法。
例如： a + b 是如下方法调用的简写： a.+(b) a 方法 b 可以写成 a.方法(b)
3.8.1、定义方法
方法的返回值类型可以不写，编译器可以自动推断出来，但是对于递归函数，必须指定返 回类型 注意：函数体应该改成叫方法体！！！如果不写等号，代表没有返回值。
3.8.2、定义函数
函数的意义：表示接受两个 Int 类型的变量，然后做累加。 经过 scala 的自动类型推断得知，最后返回的结果数据的类型也是 Int。 Function2 中 2 表示这个函数接收的参数个数是 2 个。
3.8.3、方法和函数的区别
1、函数可以作为参数传递给方法，也就是说函数可以作为方法的参数
在函数式编程语言中，函数是“头等公民”，它可以像任何其他数据类型一样被传递和操作 案例：首先定义一个方法，再定义一个函数，然后将函数传递到方法里面
2、函数可以作为方法的参数，但是也可以作为函数的参数，例如：
3、方法也可以作为方法的参数。在需要传入函数作为参数的位置上传入一个方法的话，那 么这个方法会被自动的转换为函数作为参数，也可以通过“_”把方法转换为参数
4、方法也可以作为函数的参数。其实，原理就是方法会被自动转换为函数，所以也就是传 入一个函数到一个函数作为参数。
package com.aura.mazh.day1.core
/**
* 作者： 李涛： https://blog.csdn.net/qq_42246689
*/
object MethodAndFunctionDemo {
// 定义一个方法 // 方法 m2 参数要求是一个函数，函数的参数必须是两个 Int
类型
// 返回值类型也是 Int
类型
def m1(f: (Int, Int) => Int) : Int = f(2, 6)
// 定义一个计算数据不被写死的方法 def m2(f: (Int, Int) => Int, x:Int, y:Int) : Int = f(x, y)
// 定义一个需要两个 Int类型参数的方法
def m3(x:Int, y:Int):Int = x + y
// 定义一个函数 f1 ，参数是两个 Int类型，返回值是一个 Int类型
val f1 = (x: Int, y: Int) => x + y
// 再定义一个函数 f2
val f2 = (m: Int, n: Int) => m * n
//main方法
def main(args: Array[String]) {
// 调用 m1方法，并传入 f1函数
val r1 = m1(f1)
println(r1)
// 调用 m1方法，并传入 f2函数
val r2 = m1(f2)
println(r2)
// 调用 m2方法， 传入 f1函数
val result1 = m2(f1, 2, 4)
println(result1)
// 调用 m2方法，传入 f2函数
val result2 = m2(f2, 2, 4)
println(result2)
// 调用 m2方法， 传入 mm方法作为参数
println(m2(m3, 2, 4))
}
}3.8.4、将方法转换成函数使用
3.9、Scala 函数式编程特点 S
（1）高阶函数（Higher-order functions）
（2）闭包（closures）
（3）模式匹配（Pattern matching）
（4）单一赋值（Single assignment）
（5）延迟计算（Lazy evaluation）
（6）类型推导（Type inference）
（7）尾部调用优化（Tail call optimization）
（8）类型推导（Type inference）