1 变量和函数
变量：
Scala 有两种变量， val 和 var。
val：常量，类似于 Java 里的 final 变量。一旦初始化了， val 就不能再赋值了。
va： 如同 Java 里面的非 final 变量。var在生命周期中可以被多次赋值。
下面是一个 val 的定义：
eg:
val x:T val x:T=e
var x:T var x:T=e
函数：定义 def
2 结构控制语句
判断语句 if：
if(A)
B
else
C
eg:
def min(x:Int,y:Int):Int={
var a=x
if(x>y)
a=y
return a
}
循环(while/do语句)
while(A) B
或者：
do B while(A)
（先执行一次循环体）
枚举(for表达式)
For表达式能用任意条件进行各种形式的枚举：
for(i<- e)
E(i) //表达式
注：发生器遍历e中的元素，每一次枚举运行表达式E(i)
e可以是各种集合，包括数组、列、表达式等，或是有上下界的数值范围：
1 to 4 （1=<i<=4)
1 until 4 (1=1=<i<=4-1)(不包含上界）
yield关键字：
for(i <- e)
yeild E(i) //用于赋值，即把每一次枚举的值记录在集合中
若E(i)由花括号括起，yield必须在花括号外，即：
for(i <- e)
yeild {E(i)}
匹配(match表达式)
类似于switch：
a match{
case e1=> E1
case e2=> E2
.... ....
case_=>...
}
若a匹配e1则执行E1，若a匹配e2，则执行E2 ，以此类推
在case后接_代表任意，
match表达式可以直接赋值：
eg:
val sign=a match{
case e1=> 123;
case e2=>"123";
}
异常处理(throw/try)
try{函数体}
catch{
case....;
case....;
}
finally{
A.close()
}
输出(print/println)
print(A)/println(A):A可以是值或者表达式，当A是表达式时，则输出表达式的值
println 输出时自动换行
输入(readLine)
输入通常使用read函数，readLine是从控制台读取一行输入，指定类型时为readT，T是所指定的类型，如
val age=readInt()
在控制台输入：zhangsan
其他语句
return 语句表示返回某个值，但是Scala事实上无须使用return语句
声明函数时使用return语句，必须声明返回值的类型，如def abd():T={return}
break/continue在C++中非常常见的控制结构语句，但在Scala中是不必要的，可以
使用布尔值类型的量通过IF语句进行控制
3 数组
定长数组声明：
val A=new Array[T](N) eg val A=new Array[Int](10)
数组成员默认初始化：Int初始化为0，String默认初始化为Null
也可以新建数组时给出值：
val B=Array(N1,N2)
数组初始化后能赋值：或是对指定的数组成员赋值：
val G=B+Array(1,2) val G=B-Array(1,2)
变长数组：
import scala.collection.mutable.ArrayBuffer
val C=new ArrayBuffer[T]() //声明一个空数组，此时C是一个全空数组，数组元素为0
变长数组操作：
在数组尾部加一个类型为T的元素e1，e2、e3：
C+=e1
C+=(e2,e3)
在数组尾部增加数组Array(e2,e3)
C++=Array(e2,e3)
移除最后一个元素
C.timEnd(1)
在第二个元素后插入e3：
C.insert(2,e3)
在第二个元素后插入e2,e3,e4：
C.insert(2,e2,e3,e4)
移除第3个元素后的一个元素：
C.remove(3)
移除第3个元素后的2个元素：
C.remove(3,2)
D=C.toArray //把变长数组转为定长数组D
E=A.toBuffer // 把定长数组转为变长数组
数组遍历：
for(i < - C) println(i) 直接遍历数组的成员
for(i < - 0 to （ C.length-1） )println(C(i)) 通过遍历数组的下标获得成员 遍历数组C中的所有成员并输出
额外的，有
for(i < - 0 to (C.length,2) ) println(C(i)) 每两个元素一条进行遍历
for(i < - (0 to C.length).reverse) println(C(i)) 倒序遍历
同过for语句枚举数组成员，可以实现多种数组控制，如把数组成员各加1并生成新数
组： val NEW=for(i < - C) yield i+1 这种数组生成是对应原数组类型的(定长/变长)
4 映射
数组时包含一组元素的集合，映射是包含一组键值对应元素的集合
不可变映射：
val Z=Map(a1 -> b1,a2->b2,a3->b3)
val Z=Map((a1,b1),(a2,b2),(a3,b3))
注：an 与bn 的类型可以不一致，an是键，bn是值，an互不相同，bn可以相同
获取映射对应键的值：
val a=Z(an）或val b=Z.get(an)
当映射中不含对应的键时抛出异常，
可以利用contains方法检查映射中是否含有某个键
val c=Z.contains(an) //返回布尔值
组合调用：
val d=Z.getOrElse(an,0)
可变映射
val Y=scala.collection.mutable.Map((a1,b1),(a2,b2),(a3,b3))
val X=new scala.collection.mutable.Map[T1,T2]
可变长映射的键值操作跟变长数组类似：
Y(an)=bn //有这个值则更新，无则新建对应的值
Y+=(a4->b4,a5->b5) //增加键值对
Y-=(a4) //删除键值对
对于不可变映射可以通过构造新的映射来增删其键值
val W=Z+(a4->b4,a5->b5) //新建了新的映射
val V=W-(a4->b4,a5->b5)
映射枚举：
for((i,j)<-Z)
E(i,j)
互换映射的键值：
for((i,j)<-Z)
yield(j,i)
获取映射内键的集合或值的集合：
val e=Z.keySet
val f=Z.values
5 元组
val g=(1 , 1.2，‘A’) //(Int,Double,Char)类型的元组
val one=Array(‘a’，‘b’，‘c’ )
val three=one.zip(two） 或 val three=one zip two //对应的就生成一个元素是二元的数组
val four=one.zip(two).toMap 或 val four = one zip two toMap //对应的生成一个以数组one为键，数组two为值的映射
6 包的引用
Scala通过不同的包能使用很多类型的表达式，而包的引入在Scala中相当灵活
包是用来管理名称的，包括该名称的声明、定义等
能给已有的包增加名称，或者创建新的包
包是能互相嵌套的如： scala.collection.mutable的结构如下
package scala { package collection { package mutable {……} } }
包声明链scala.collection.mutable并不使scala与scala.collection可见
包声明链亦不对包含的包进行声明
即声明scala.collection并不意味着声明scala.collection.mutable
{……}号之间声明的量只有在{}内是有意义的
{val a=0... {...val b=a}...} 内层能调用外层声明的量
{val a=b...{val b=0...}...} 外层不能调用内层声明的量
内层声明与外层声明相同时，内层使用的是内层的声明，外层使用的是外层的声明
如： val x=2 for（ i < - 1 to 4） print(x+i)
val x=2 for(x < - 1 to 4) print(x+x)
{val a=0... {...val b=a}...} 内层能调用外层声明的量
{val a=b...{val b=0...}...} 外层不能调用内层声明的量
内层声明与外层声明相同时，内层使用的是内层的声明，外层使用的是外层的声明
如： val x=2 for（ i < - 1 to 4） print(x+i)
val x=2 for(x < - 1 to 4) print(x+x)
{val a=b...{val b=0...}...} 外层不能调用内层声明的量
内层声明与外层声明相同时，内层使用的是内层的声明，外层使用的是外层的声明
如： val x=2 for（ i < - 1 to 4） print(x+i)
val x=2 for(x < - 1 to 4) print(x+x)
内层声明与外层声明相同时，内层使用的是内层的声明，外层使用的是外层的声明
如： val x=2 for（ i < - 1 to 4） print(x+i)
val x=2 for(x < - 1 to 4) print(x+x)
如： val x=2 for（ i < - 1 to 4） print(x+i)
val x=2 for(x < - 1 to 4) print(x+x)
val x=2 for(x < - 1 to 4) print(x+x)
