【scala 语法基础】变量、函数、控制结构、数据类型

一、主要内容
Scala中变量的声明与函数定义
Scala中的控制结构
Scala中的数据类型

1:变量声明与函数定义
变量声明:val 和 var ,两者的区别是val声明的变量是不可变的,而var声明的变量可变

带返回值

scala> def max(x:Int,y:Int):Int = {  
     |     if(x>y) x  
     |     else    y  
     | }  
max: (x: Int, y: Int)Int  

scala> max(1,2)  
res5: Int = 2  

不带返回值

scala> def helloworld()=println("HelloWorld")  
helloworld: ()Unit  

2:控制结构
1) 判断(if)
类似于上边函数定义中的max函数
2) 循环(while/do)
while 语句包括状态判断和循环体,只要当前状态判断为真,就执行循环体一遍,然后进行下一状态判断,判断为假时终止判断,形如 while (A)B
do语句和while相反,先执行循环体一遍,然后进行状态判断,状态判断为真,则继续执行循环体,否则终止循环,形如 do B while(A)

scala> var m =3  
m: Int = 3  

scala> while(m!=0){  
     |    println(m)  
     |    m -= 1  
     | }  
3  
2  
1  

scala> var n =3  
n: Int = 3  

scala> do{  
     |    println(n)  
     |    n -= 1  
     | }while(n!=0)  
3  
2  
1  

3) 枚举(for)
for的两种实现

scala> for(i<- 1 to 3)  
     |     println(i)  
1  
2  
3  

scala> for(i<- 1 until 3)  
     |     println(i)  
1  
2  

4) 匹配(match表达式)
scala中的match类似于其他语言中的switch,从上往下进行匹配

scala> val a = "gyt"  
a: String = gyt  

scala> a match{  
     |   case "gyt" => println("OK")  
     |   case "cyan" => println("no")  
     | }  
OK  

5) 异常处理(throw/try)
Scala通过throw抛出一个异常,其异常捕获和处理与java十分类似

scala> if(true){  
     |    println("throw new exception")  
     |    throw new IllegalArgumentException  
     | }  
throw new exception  
java.lang.IllegalArgumentException  
  ... 35 elided  
scala> try{   
     | val file = new FileReader("input.txt")    
     | }catch{    
     |  case ex: FileNotFoundException => //handle missing file   
     |  case ex: IOException => //handle other I/O error    
     | }finally{    
     |  println("end")  
     | }  
end  

6) 输出(print/println)
一个不换行输出,一个换行输出
7) 输入(readline)
输入通常使用read函数,readline是从控制台输如一行,指定类型为readT,T为类型,例如

readscala> val name = readLine(“Your Name: \n”)
warning: there was one deprecation warning; re-run with -deprecation for details
Your Name:
name: String = thinkgamer

8) 其他语句
return语言表示返回某个值,但是Scala事实上无需使用return语句,对于函数来说,其默认返回值是最后出现的一个值,不用特别注明,如需要返回的值,并非最后出现时,可在函数体后加上该值的标识符使之出现,声明函数时使用return语句,必须声明返回值类型,例如 def max:T = {return}
break/continue在C++中非常常见的控制结构语句,但在Scala中是不必要的,可以使用布尔值类型的两通过if语句进行控制

3:数据结构
1) 数组
使用new来实例化一个类,当你创建一个对象的实例时,你可以使用数值或者类型参数

scala> val abc = new Array[String](3)  
abc: Array[String] = Array(null, null, null)  

scala> abc(0)="thinkgamer"  

scala> abc(1)="cyan"  

scala> abc(2)="GQ"  

scala> for(i<- 0 to 2)  
     |   println(abc(i))  
thinkgamer  
cyan  
GQ  

这里也说明下为什么Scala使用()来访问数组元素,在Scala中,数组和其他普遍的类的定义一样,没有什么特别之处,当你某个值后面使用()时,Scala将其翻译成对应对象的apply方法,因此本例中abc(0)其实调用abc.apply(0)方法,这种表达方法不仅仅只限于数据,对于任何对象,如果在其后面使用(),都将调用该对象的apply方法,同一,日过对某个使用()的对象复制,比如
abc(0)=”thinkgamer”
scala将这种复制转换为该对象的update方法,也就是abc.update(0,”thinkgamer”),因此上边的例子也可以使用传统的方法调用,可以写成:

scala> val new_abc = new Array[String](3)  
new_abc: Array[String] = Array(null, null, null)  

scala> new_abc.update(0,"aaa")  

scala> new_abc.update(1,"bbb")  

scala> new_abc.update(2,"ccc")  

scala> for(i<- 0 to 2)  
     |   println(new_abc(i))  
aaa  
bbb  
ccc  

从这点来收,数组在scala中并不是某种特殊的数据类型,和普通的类并没有什么区别
不过scala还是提供了初始化数组的简单的方法,上述的例子可以这样写:

scala> val abc = Array("thinkgamer","cyan","GQ")  
abc: Array[String] = Array(thinkgamer, cyan, GQ)  


数组的输出可以采用while或者foreach或者for进行输出

scala>  val abc = Array("thinkgamer","cyan","GQ")  
abc: Array[String] = Array(thinkgamer, cyan, GQ)  

scala> var i = 0  
i: Int = 0  

scala> while(i<abc.length){  
     |   println(abc(i))  
     |   i+=1  
     | }  
thinkgamer  
cyan  
GQ  

scala> abc.foreach(str=>println(str))  
thinkgamer  
cyan  
GQ  

2):Lists
Scala的List和Java不同,不能被改变,这样做的一个好处是方法与方法之间关联性较小,从而方法变得更可靠和重用性高,使用这个规则也就意味着变量的设置是不可修改的,这也就避免了多线程访问的互锁问题

scala> val one = List(1,2,3)  
one: List[Int] = List(1, 2, 3)  

scala> val two = List(4,5)  
two: List[Int] = List(4, 5)  

scala> val three = one:::two  
three: List[Int] = List(1, 2, 3, 4, 5)  

:::方法表示连接两个列表,当然列表定义了::方法(右操作符),用于向列表添加元素

scala> val four = three::6::7::Nil  
four: List[Any] = List(List(1, 2, 3, 4, 5), 6, 7)  

scala> val five = 1::2::3::4::Nil  
five: List[Int] = List(1, 2, 3, 4)  

Nil表示空列表
Scala的List类还定义了其他很多很有用的方法,比如head,last,length,reverse,tail等这里就不一一说明了,具体可以参考List的文档
3) Tuples
Scala中另外一个很有用的容器类是Tupels,和Lists不同的Tuples可以包含不同类型的数据,而List只能包含同类型的数据,Tuples在方法需要返回多个结果时非常有用(Tuple对应数学的矢量的概念)
一旦定义了一个元组,可以使用._和索引来访问元组的元素(矢量的分量,注意和数组不同的是,元组的索引从1开始)

scala> val pair = (22,"one")  
pair: (Int, String) = (22,one)  

scala> println(pair._1)  
22  

scala> println(pair._2)  
one  

元组的实际类型取决于它的分量的类型,比如上边的pair的类型实际为Tuple2[Int,String],目前Scala支持的元组的最大长度为22,如果有需要,你可以扩展更长的元组
4) Set

scala> var set = Set("a","b")  
set: scala.collection.immutable.Set[String] = Set(a, b)  

scala> set+="c"  

scala> set  
res8: scala.collection.immutable.Set[String] = Set(a, b, c)  

scala> println(set.contains("c"))  
true  

缺省情况Set为Immutable Set,如果你需要使用可修改的集合类(Set类型),你可以使用全路径来指明Set,比如scala.collection.mutalbe.Set

5) Map
Map的基本用法如下(Map类似于其他语言中的关联数据如PHP)

scala> val  roman =Map(1->"I",2->"II")  
roman: scala.collection.immutable.Map[Int,String] = Map(1 -> I, 2 -> II)  

scala> println(roman(1))  
I  

scala> println(roman(2))  
II  
已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页