2 Scala基本语法

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)

来自为知笔记(Wiz)

附件列表

• 6ba7d4a6-8650-4708-b0da-41f63665ae25.png