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
6ba7d4a6-8650-4708-b0da-41f63665ae25.png

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并不使scalascala.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)

 

 

 

 

 

 





 

posted @ 2014-12-28 23:18  白大虾  阅读(388)  评论(0编辑  收藏  举报