2 Scala基本语法

时间：2014-12-28 23:40:56 阅读：444 评论：0 收藏：0 [点我收藏+]

标签：

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)类型的元组

  利用方法_1、 _2、 _3访问元组的组元

  val h=g._1 或 val h=g _1





  元组把多个值捆绑在一起，使他们能同时被处理

zip方法：

   zip方法能把几个集合结合起来

val one=Array(‘a’，‘b’，‘c’ )

val two=Array（ 1， 2， 3）

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)