Scala--控制结构和函数

一、条件表达式

val s = if(x > 1) 1 else -1

s 可以是 val

var s = 0
if(x > 1) s = 1 else s = -1

s 必须是 var

表达式 val s = if(x > 1) 1 else -1的类型是Int

混合类型表达式

if(x > 1) "hello" else -1

一个是String,一个是Int,公共超类型是Any。

if(x > 1) 1 或 if(x > 1) 1 else ()

()表示Unit, "无有用值", 当做java中的void.

java、c中的三目运算符 m>1 ? 1 : -1

scala 没有，而是使用条件表达式来代替

val s =  if(m>1) 1 else -1

二、语句终止

每条语句，行尾不需要使用分号，如果在单行中写下多个语句，就需要将他们分号隔开。

if (n > 0) {r = r*n; n -= 1}

在写较长的语句，分两行来写的话，第一行不能用表示结尾的符号结尾，比如操作符+; repl模式不支持 (read evaluate print loop)

s = s0 + s1 * s2 +
s3 * 0.5 + s4

推荐使用花括号

if( n > 1) {
    r = r * n
    n -= 1
}

三、块表达式和赋值

val dis: Int = { val a = 2; val b = 4; a+b}
println(dis)

语句块的返回值取最后一个表达式，这里为 a+b的结果。

val n: Unit = { val a = 3}
println(n)

赋值语句的返回值是Unit类型类似于java中的void，结果为()

注 不要这样赋值

y = x = 1

x = 1的结果为Unit,则y的值为Unit

四、输入和输出

输出：

print("Answer:")
println( 42 )

println("Answer:" + 42)

//格式化输出使用printf    
printf("My name is %s, I am %d years old.
", "Fred", 42 )

格式化输出使用printf

换行输出println

输入：

val name = readLine("You name:")
print("Your age:")
val age = readInt()
printf("Hello %s, next year, you will be %d years old.
", name, age + 1)

readLine读取一行，带参数提示符。

readInt, readChar, readFloat, readDouble, readByte, readShort, readBoolean, readLong

println(s"")

val str = "world"
println(s"hello $str")
println(s"1+1=${1+1}")

hello world
1+1=2

println(f"")

val w = 1.2d
println(f"you weight is $w%.2f")

you weight is 1.20

println(raw"") 

println(raw"hello 
")

hello 

五、循环

while循环

while(n > 0){
    n = n*r
    n -= 1
}

for循环   变量 i 在之前并不需要指定

for(i <- 1 to 10){
    println(i)
}

until 返回一个并不包含上线的区间，最后一个值为 s.length-1

val s = "hello"
for(i <- 0 until s.length) {
    println(s(i))
}

scala没有与java for(;;)循环相关的结构

scala没有提供continue和break语句来退出循环，如果需要break时，我们该如何操作？

• 使用Breaks对象中的break方法，breakable是函数

    import scala.util.control.Breaks._

    breakable{
      for(i<- 0 to 10){
        if(i == 4){
          break
        }
        println(i)
      }
    }

• 使用嵌套函数，在函数中调用return

    def func(): Unit ={
        for(i<- 0 to 10){
          if(i == 4){
            return
          }
          println(i)
        }
      }
      func()

• 使用boolean型的控制变量

    for(i<- 0 to 10 if i < 4){
      println(i)
    }

六、高级for循环和for推导式

变量<-表达式 表示生成器

提供多个生成器

for(i<- 1 to 3; j<- 1 to 3) print ( i*10 +j +" ")

结果：11 12 13 21 22 23 31 32 33

类似于Java的嵌套for循环

每个生成器可以带一个守卫  以if开头的Boolean的表达式

for(i<- 1 to 3; j<- 1 to 3 if i != j) print ( i*10 +j +" ")

结果：12 13 21 23 31 32

定义任意多的变量，在循环中使用

for(i<- 1 to 3; from<- 4 to i; j<- from to 3) print ( i*10 +j +" ")

结果：12 13 21 23 31 32

推导式  for的循环体以yield开始，循环会构造出一个集合，每次迭代生成集合的一个值

for(i<- 1 to 10) yield i % 3

结果 Vector(1, 2, 0, 1, 2, 0, 1, 2, 0, 1)

推导生成的集合与它的第一个生成器是类型兼容的

for(c<- "Hello"; i<- 0 to 1) yield (c+i).toChar   //第一个生成器是 c<-"Hello"
for(i<- 0 to 1;c<- "Hello") yield (c+i).toChar    //第一个生成器是 i<- 0 to 1

结果：HIeflmlmop
     Vector(H, e, l, l, o, I, f, m, m, p)

七、函数

方法是对对象的操作

= 右边是函数块

def abs(x: Double) = if (x > 0) x else -x

函数可以不指定返回值类型，除非是递归函数。函数中的最后一个表达式的值即为函数的返回值。

对于递归函数，我们必须指定返回类型  = 左边是返回值类型

def fac(n: Int): Int = if (n <= 0) 1 else n * fac(n - 1)

八、默认参数和带名参数

def decorate(str:String, left:String="[", right:String="]") = left + str + right
println(decorate("hello"))    //默认参数
println(decorate("hello","(",")"))   //指定全部参数
println(decorate(left="<",str="hello",right=">"))  //带名参数

结果：[hello] 
     (hello)
     <hello>

九、变长参数

* 变长参数

    def sum(args: Int*) = {
      var result = 0
      for(arg <- args) result += arg
      result
    }
    println(sum(1,2,3,4,5,6,7,8,9))//
    println(sum(1 to 9 : _*))      //当做参数序列处理,使用 :_*
    println(sum(1 to 9)  //错误，传递整个区间

十、过程

过程不返回值

def box(s:String){  //注意 没有 =
    val border = "-"*s.length+"--
"
    println(border+"|"+s+"|
"+border)
}
box("hello")

十一、懒值

当val被声明为lazy时，他的初始化将被推迟，直到我们首次对他取值

lazy val l = {println("I am lazy");1} 
println("this is ok")
val v = l

结果：this is ok
     I am lazy

十二、异常

 

1.

val signum = if(a > 0) 1 else if(a==0) 0 else -1

2.

空 Unit

3.

Unit

4.

for(i<- 0 to 10 ;j=10-i) println(j)

5.

def countdown(n:Int) {
    for(i<- 0 to n; j=n-i) println(j)
}

6.

val str = "Hello"
var sum:Long = 0
for(i<-str) sum=sum* i.toLong

7.

val str = "Hello"
val r = (1L/:str)(_.toLong*_.toLong)

8.

def product(s:String):Long={
    (1L/:str)(_.toLong * _.toLong)
}

9.

def recproduct(str:String):Long = {
    if (str.length == 0) 1
    else str(0).toLong * recproduct(str.drop(1))
}

10.

def computex(x:Long, n:Int) :Long={
      if(n==0) 1
      else if(n%2==0) computex(x,n/2)*computex(x,n/2)
      else if(n%2==1) x * computex(x, n-1)
      else  computex(x,-n)
}

println(computex(2,3))
println(computex(4,4))

参考《快学Scala》