Scala入门
新建Scala代码文件
Scala代码的命名可以不与类名相同，但最好还是遵循这个习惯。例如WordCount.scala。
声明变量
Scala的变量分为两种类型，一种是可变变量var，一种是不可变变量val。在声明变量时，一定要声明是可变变量还是不可变变量。
两者的区别在于val在声明时就必须被初始化，而且初始化之后就不能再次赋值；var声明的时候可以进行初始化，也可以进行默认初始化，初始化以后还可以再次对其赋值。默认初始化时一定要声明变量的类型，每一种变量类型都会对应一个默认值，它们可能是不同的。（变量声明比Python要严格）
val s: String = "Hello World!" // 再次赋值会报错
var n: Double = 3.2
var a: Int = _ // 默认初始化
声明变量是可以写出变量的类型，也可以不写，因为Scala可以自动推测变量类型（默认初始化一定要写）。
val x = 99.22
// 返回x: Double = 99.22
Range
Python中的range函数是一个非常常用的函数，Scala中也有类似的表达式。
1 to 5 // 返回Range(1, 2, 3, 4, 5)，左右都是闭的
1 until 5 // 返回Range(1, 2, 3, 4)，左闭右开
1 to 10 by 2 // 2是步长
另外，Scala中的range还支持字符型和浮点型，这是Python不支持的。
'a' to 'z'
0.8 to 6.9 by 0.6
打印
Scala有三种常用的打印函数。
print("hello world") // 不带换行
println("hello world") // 自带换行
printf("hello world") // 用法和C语言一样
if语句
if (x>0) {
println("This is a positive number")
}
else if (x==0) {
println("This is a zero")
}
else {
println("This is a negative number")
}
语法都是差不多的，区别在于Scala的if语句可以用于给变量赋值。
val a = if (x > 0) 1 else 0
Python中也有类似语句。
a = 1 if x > 0 else 0
while语句
var i = 10
while (i < 10) {
println(i)
i -= 1
}
也有do-while语句。
var i = 10
do{
println(i)
i -= 1
}while (i > 0)
for语句
for (i <- 1 to 5) {
println(i)
}
括号中的赋值比较不一样，其中的1 to 5可以用前面的介绍的Range代替。
多重循环可以直接在一个for里面搞定。
for (i <- 1 to 5; j <- 1 to 3) {
println(i*j)
}
for推导式
有时候，我们需要对上述过滤后的结果进行进一步的处理，这时，就可以采用yield关键字，对过滤后的结果构建一个集合。
for (i <- 1 to 5 if i%2==0) yield i // 返回Vector(2, 4)
Array
Array在Scala中是定长数组，需要注意的是，Scala中使用索引时用的是圆括号，跟其他语言不同。
val intValueArr = new Array[Int](3) //声明一个长度为3的整型数组，每个数组元素初始化为0
intValueArr(0) = 12 //给第1个数组元素赋值为12
intValueArr(1) = 45 //给第2个数组元素赋值为45
intValueArr(2) = 33 //给第3个数组元素赋值为33
Scala还提供了更加简洁的初始化方式。
val intValArr = Array(12,45,33)
val myStrArr = Array("BigData","Hadoop","Spark")
List
List给我的感觉比较像链表，可以查询表头表尾，还可以用::操作在头部增加新元素。
val L1 = List(1,2,3)
L1.head // 返回 Int = 1
L1.tail // 返回 List[Int] = List(2, 3)
val L2 = 0::L1 // 返回 L2: List[Int] = List(0, 1, 2, 3)
还可以用:::操作连接两个列表。
val L3 = L1:::L2 // 返回 L3: List[Int] = List(1, 2, 3, 0, 1, 2, 3)
Tuple
元组可以包含不同类型的元素，直接用圆括号将元素括起来就可以声明一个元组，访问元组中的某个值时也跟之前的不一样，用圆括号会报错。Python中也有元组，跟这个元组的区别是Python的元组就是不可变的。
val tuple = ("scala", 7.21, 'a', 10)
tuple._1 // 返回String = scala
Set
集合是不重复元素的合集，集合中的元素没有顺序，但是允许你快速找到某个元素。Scala 集合分为可变的和不可变的集合。默认情况下，Scala 使用的是不可变集合，如果你想使用可变集合，需要引用scala.collection.mutable.Set包。
scala> var mySet = Set("Hadoop","Spark")
mySet: scala.collection.immutable.Set[String] = Set(Hadoop, Spark)
scala> mySet += "Scala" //向mySet中增加新的元素
scala> println(mySet.contains("Scala"))
true
# 声明一个可变集合
scala> import scala.collection.mutable.Set
import scala.collection.mutable.Set
scala> val myMutableSet = Set("Database","BigData")
myMutableSet: scala.collection.mutable.Set[String] = Set(BigData, Database)
scala> myMutableSet += "Cloud Computing"
res0: myMutableSet.type = Set(BigData, Cloud Computing, Database)
scala> println(myMutableSet)
Set(BigData, Cloud Computing, Database)
Map
在Scala中，映射(Map)是一系列键值对的集合，也就是，建立了键和值之间的对应关系。在映射中，所有的值，都可以通过键来获取。Python中对应的是dict（字典）。默认情况下创建的是不可变映射。
val university = Map("XMU" -> "Xiamen University", "THU" -> "Tsinghua University","PKU"->"Peking University")
// university: scala.collection.immutable.Map[String,String]
university("XMU") // String = Xiamen University
如果要定义可变映射，就要导入相关的包。
import scala.collection.mutable.Map
val university2 = Map("XMU" -> "Xiamen University", "THU" -> "Tsinghua University","PKU"->"Peking University")
university2("XMU") = "Ximan University" //更新已有元素的值
university2("FZU") = "Fuzhou University" //添加新元素
循环遍历映射，是经常需要用到的操作，基本格式是：
for ((k,v) <- university) {
printf("Code is : %s and name is: %s\n",k,v)
}
Iterator
迭代器包含两个基本操作：next和hasNext。next可以返回迭代器的下一个元素，hasNext用于检测是否还有下一个元素。有了这两个基本操作，我们就可以顺利地遍历迭代器中的所有元素了。
通常可以通过while循环或者for循环实现对迭代器的遍历。
val iter = Iterator("Hadoop","Spark","Scala")
while (iter.hasNext) {
println(iter.next())
}
函数定义
def sum(a: Int, b: Int, c: Int): Int = a + b + c
定义好sum之后，如果每次函数里面的一部分参数都是固定的，那每次写起代码来就很冗余。
那么就可以定义一个偏应用函数，固定其中的一部分参数，每次只需要传入剩下不固定的参数即可。
def sum(a: Int, b: Int, c: Int): Int = a + b + c
val sum_a = sum(1, _: Int, _: Int)
sum_a(2, 8) // 返回11
匿名函数
匿名函数，顾名思义就是不需要给函数命名，跟Python的Lambda表达式很类似（感觉就是一个东西）。
(num: Int) => num * 2
val numList = List(-3, -5, 1, 6, 9)
numList.filter(x => x > 0 )
占位符
Scala中有占位符_，对于之后的每个元素，都会依次传进去。
val numList = List(-3, -5, 1, 6, 9)
numList.filter(_ > 0)
// 返回List[Int] = List(1, 6, 9)
读写文件
Scala本身不像Python有读写文件的语句，而是直接使用Java的文件IO操作。可以参考陈家大少的博客
