本系列博客以《Programming in Scala 2nd Edition》为主，围绕其中的代码片段进行学习和分析。
本文主要梳理Chapter2和Chapter3中涉及到的主要概念。
一、变量定义时的val和var
在Scala中定义一个变量可以使用两种关键字var和val。其中val类似于Java中的final类型变量，值不可变。var定义的变量值是可变的。
1、val变量
当给一个val变量重新赋值时就会出现如下提示：
2、var变量
如果确实需要更改某个变量的值，可以使用var。下面这个就不会出现错误提示
二、函数的定义
1、简单定义
定义一个求两个变量最大值的函数
def max(x: Int, y: Int): Int = {
if (x > y) x
else y
} 
接下来我们仔细分析一下这个定义的语法结构，定义一个函数以def开头，接下来是函数名称max，传入参数列表(x: Int, y: Int)，然后是返回类型Int，用等号与函数体相连。
２、简化
其实这个函数可以简写成以下形式，scala会根据函数后面的表达式，自动推算出返回类型。下面这个if表达式中，返回类型应该是if的两个分支结果类型的最近一个公共父类。
def max2(x: Int, y: Int) = if (x > y) x else y 
3、无返回值函数
前面两种定义的函数，都会有一个返回值，接下来定义一个没有返回值的函数，
def greet() = println("Hello, world!") 
三、循环结构
在任何编程语言中循环结构都是最重要，使用最频繁的一种定义结构。接下来简要介绍一下其中的while，foreach，以及for循环。
1、while循环
定义如下，
var i = 0
while (i < args.length) {
println(args(i)
i += 1
}运行该方法时传入参数为Scala is fun，结果如下，
2、foreach循环
上面的功能可以使用foreach简写，下面代码中调用args数组的foreach方法，注意该方法中接收的参数是一个函数。由于args是一个String类型的数组，Scala编译器会自动推算出传入的函数中arg的类型也是String，所以不需要写成arg: String的形式。
args.foreach(arg => println(arg))结果如下：
在Scala中，当一个函数表达式中只有一个语句，并且只接收一个参数时，可以进一步简写。最终这个循环简写成
args.foreach(pringln)总结一下，三种foreach循环的写法如下：
args.foreach(arg => println(arg))
args.foreach((arg: String ) => println(arg))
args.foreach(println) 在第二种写法中表示了Scala中怎样传递一个函数表达式当参数，这个函数表达式参数没有函数名，参数和函数体用=>分隔，参数需要用圆括号包围。
3、for循环
for (arg <- args)
println(arg)输入参数for arg in args运行代码，结果如下：
四、构造一个对象
和Java中一样，在Scala中也可以使用new关键字生成一个类的对象，并且在构造时，可以往构造函数中传入一些参数。
1、简单对象
比如下面这个表达式中，会生成一个java.matm.BigInteger类型的对象，并且值为12345。
val big = new java.math.BigInteger("12345")2、数组对象
定义一个数组对象，并赋值，最后循环打印出该数组中的内容。0 to 2表示生成0, 1, 2的序列值。
val greetStrings = new Array[String](3)
greetStrings(0) = "Hello"
greetStrings(1) = ", "
greetStrings(2) = "world!\n"
for (i <- 0 to 2)
print(greetStrings(i)) 严格意义上，在Scala中是没有操作符这个说法的，比如说+,-,*,/，其实都是方法调用的简写形式。 1 + 2其实是Int型对象1调用一个函数名为+的函数，传入的对象是Int型变量2。所以完整的写法是(1).+(2)
在上面的例子中，还可以看到，和Java中不同的是，数组下标是用圆括号传递的。比如greetStrings(1)其实是greetStrings.apply(1)的简写形式。调用的是数组的apply方法，传入参数是数组下标值，数组的apply方法的作用是获取传入下标处的元素值。在Scala中任何对象后面直接用圆括号接收的值，其实都是该对象调用apply方法的简写形式。
但是如果对象后面直接跟圆括号并传入参数，最后用=进行赋值，实际上调用的是该对象的update方法，比如
greetStrings(0) = "Hello"编译器会将其解析成
greetStrings.update(0, "Hello")另外，数组的初始也可以在定义时一并完成，比如
val numNames = Array("zero", "one", "two")上面的定义会自动确定Array中的元素类型为String。并且这个写法其实也是调用了Array的apply方法。所以等价于下面这种写法
val numNames2 = Array.apply("zero", "one", "two")联想一下第一节中的内容，你认为一个Array对象到底是可变的呢，还是不可变的？Array对象是可变的(mutable)对象。因为，虽然在一个Array被构造出来之后，其长度是不可变的，但是其中的元素还是可以被重新赋值的。
五、List的用法
如果想要实现一个不可变(immutable)的对象列表，可以使用马上要介绍到的scala.List。在Java中使用的List是java.util.List类型，这个List是mutable类型的。
val oneTwoThree = List(1, 2, 3)1、List中的方法
（1）:::
在List中，有一个方法:::用于连接两个List，比如，
val oneTwo = List(1, 2)
val threeFour = List(3, 4)
val oneTwoThreeFour = oneTwo ::: threeFour
println(oneTwo +” and “+ threeFour +” were not mutated.”)
println(“Thus, “+ oneTwoThreeFour +” is a new list.”)
（2）::
这个方法用于在List前面新增加一个元素
val twoThree = List(2, 3)
val oneTwoThree = 1 :: twoThree
println(oneTwoThree)将::左边的对象当作一个元素追加到::右边的List元素之前，上面这个表达式的最终结果是
但是如果
val oneTwoThreeFour = oneTwo :: threeFour结果是新的List中第一个元素为oneTwo这个List，如下：
（3）Nil
其实这个不是一个方法，Nil的作用是生成一个空的list。结合::方法和Nil也可以构造并初始化一个List
val oneTwoThree = 1 :: 2 :: 3 :: Nil 表示的是将3追加到空list的前面，形成一个新的List，然后追加2，又生成一个新的List，最后追加1。那么最终结果是,
如果最后不写Nil，是无法将这些值转化成一个List的。
最后列举出List常见的用法:
| 用法 | 作用及返回值 |
|---|---|
| List() 或 Nil | 生成一个空的List |
| List(“Cool, “Tools”, “rule”) | 构造一个List对象并初始化 |
| val thrill = “will” :: “fill” :: “until” :: Nil | 构造一个List对象并初始化 |
| List(“a”, “b”) ::: List(“c”, “d”) | 将两个List中的元素展开并拼接生成一个新的List |
| thrill(2) | 获取thrill中的第2个元素，即rule |
| thrill.count(s => s.length ==4) | count方法传入一个方法，统计出thrill中元素字符长度为4的所有元素个数，结果为2 |
| thrill.drop(2) | 返回一个去除thrill中前2个元素的list，结果为List(“until”) |
| thrill.dropRight(2) | 去除右边2个元素，结果为List(“will”) |
| thrill.exists(s => s == “untill”) | exists接收一个方法，判断thrill List中是否包含”untill”元素，结果为true |
| thrill.filter(s => s.length == 4) | 筛选出thrill中长度为4的元素，结果为List(“will”, “fill”) |
| thrill.forall(s => s.endsWith(“l”)) | 判断是否所有元素都以l结尾，只有当所有元素都满足该条件时才返回true。可以类比exists，exists是或的关系，forall是与的关系 |
| thrill.foreach(s => print(s)) | 使用传入的方法循环处理thrill中的每一个元素。这里是打印 |
| thrill.foreach(print) | 上面的简写形式 |
| thrill.head | 获取thrill中的第一个元素，结果为”will” |
| thrill.init | 返回一个去除最后一个元素的list，结果为List(“will”, “fill”) |
| thrill.isEmpty | 判断thrill是否为空，结果为false |
| thrill.length | 获取thrill中的元素个数，结果为3 |
| thrill.map(s => s + “y”) | 返回一个新的list，新的list中每一个元素为thrill中元素依次调用传入方法的结果，结果为List(“willy”, “filly”, “untily”) |
| thrill.mkString(“,”) | 将thrill中的元素用逗号拼接，返回一个String，结果为”will,fill,untill” |
| thrill.remove(s => s.length == 4) | 返回一个新的list，这个list中不包含thrill中长度为4的元素，结果为List(“until”) |
| thrill.reverse | 翻转thrill中的元素，返回List(“until”, “fill”, “will”) |
| thrill.sort((s, t) => s.charAt(0).toLower < t.charAt(0).toLower) | sort方法接收一个方法当参数，这个传入的方法中需要接收两个参数值，根据这两个元素的第0个字符编码大小排列，结果为true表示排在前面。结果是List(“fill”, “untill”, “will”) |
| thrill.tail | 去掉thrill的第一个元素，得到一个新的list。结果是List(“fill”, “until”) |
六、Tuple的用法
Tuple也是immutable的，当需要一个方法返回多个对象时，可以考虑使用Tuple，对比Java中，为了返回多个对象，一般会构造一个JavaBean对象，将需要返回的值都由这个JavaBean来中转。Scala中的Tuple就可以理解成一个JavaBean对象，只不过这个对象不需要你去创建，并且不需要指定JavaBean的类名，如果在下面这个Tuple的初始化前加一个new ClassName的话，几乎就是构造一个JavaBean对象的代码了。
val pair = (99, "Luftballons")
print(pair._1)
print(pair._2)获取Tuple中的元素，可以用_1的形式来实现。List中是用list(1)的形式来访问指定元素，那么Tuple中为什么不行呢？这是因为List中的元素一般都是相同的类型，List的apply方法知道返回的对象什么类型的。而Tuple中的元素一般为不同类型，_1和_2的类型可能就完全不同。
七、Set和Map的用法
1、Set
在Scala中Set的类继承关系如下图：
最上面有三个名字相同的trait，Scala中的trait类似于Java中的interface，这三个名称相同的trait可以用包名加以区分。
创建一个Set对象可以使用以下方法，类似于初始化一个Array对象或者List对象，
var jetSet = Set("Boeing", "Airbus")
jetSet += "Lear"
println(jetSet.contains("Cessna"))初始化jetSet对象包含两个String后，第二行代码等价于jetSet = jetSet + "Lear"。对mutable类型的Set，是将Lear追加到当前对象的最后。而对于imutable类型的Set，则是将Lear追加到最后，并返回一个新的Set对象。
执行结果如下图，
如果需要指定初始化一个mutable类型的Set，在最开始使用import命令导入对应的Set即可，
import scala.collection.mutable.Set
val movieSet = Set("Hitch", "Poltergeist")
movieSet += "Shrek"
println(movieSet)2、Map
首先看一下Map的类结构图，这个结构图和Set很相似。
初始化一个Map对象，使用以下代码
import scala.collection.mutable.Map
val treasureMap = Map[Int, String]()
treasureMap += (1 -> "Go to island.")
treasureMap += (2 -> "Find big X on ground.")
treasureMap += (3 -> "Dig.")
println(treasureMap(2))结果如下
在初始化之前使用import导入需要使用的类型。key和value之间用”->”连接。使用+=将新的键值对导入Map对象中。
也可以在声明时直接初始化
val romanNumeral = Map(1 -> "I", 2 -> "II", 3 -> "III", 4 -> "IV", 5 -> "V")
println(romanNumeral(4))