Scala详解---------控制结构和函数

来源：互联网发布：考察社区红色网络教育编辑：程序博客网时间：2024/05/31 19:02

条件表达式：

Scala的if else语法结构和Java的一样，不过，Scala的if else表达式有值，这个值就是跟在if或者else后面的表达式的值。

例如： if(x>0) 0 else 1

该表达式的值就是0或者1，具体的根据x值判断。

可以将if else表达式的值赋值给变量：

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

这个跟如下语句一致：

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

当然，第一种写法更好，它可以用来初始化一个val（常量），而第二种s必须是var（变量）。

注：Scala中的分号（；）绝大多数情况下不是必需的。

Java中的 x>0 ? 0:1 等同于 Scala表达式if(x>0) 0 else 1

Scala中，每个表达式都有一个类型。表达式if(x>0) 0 else 1的类型是Int，因为两个分支的类型都是Int。

混合类型表达式if(x>0) "hello" else 1，这个表达式的类型是两个分支类型的公共超类型，示例中，“hello”是java.lang.String类型，1是Int类型，

其公共超类型为Any。

如果else部分没有，if(x>0) 0 ，有可能if没有输出值。但在Scala中，每个表达式都是有值的。该示例中，如果if没有输出值，那么其输出就是一个“无有用值”占位符，

写作()，其类是Unit类，类似Java中的Void。上述语句等同于if(x>0) 0 else () 。

注： 在Scala中没有Switch语句，其存在强大的模式匹配机制（后面会讲到）。

语句终止：

在Java中，每个语句都有分号，而在Scala中，行尾的位置不需要分号。在}、else及类似的位置也不必写分号，只需要能够从上下文判断这里是语句终止即可。

如果需要在单行写下多个语句，就需要分号将这些语句隔开。如：

if(x>0) { k = r*x ; n +=4} 通过分号将k = r*x 与n +=4 这个语句隔开，由于存在} ，所有n +=4结尾不需要加分号；

如果书写过长的语句，需要分开两行来写的话，确保第一行以一个不能用做语句结尾的符号结尾。比较好的选择是用操作法结尾。

如： sum = s0 + (V1-V2)*t + // 告诉解析器这里不是语句的结尾

0.8*(V3-V4)*t+s1

在实际编码中，通过使用Kemighan&Ritchie风格的花括号编码。如：

if(x>0) {

n = n*x

x -=1

}

以{结尾告诉编译器后面还存在内容。

块表达式和赋值：

Java中，块语句是一个包含于{}中的语句序列。但逻辑分支或者循环中放置多个语句是，都可以使用块语句。

Scala中，{}块语句包含一系列的表达式，其结果也是一个表达式。块的最后一个表达式的值就是块的值。

这个特性对某个val初始化需要分多个步骤完成的情况很有用。如：

val dis = { val x = t1-t2; val y = t3 -t4 ; sum(x,y)}

{}块中取值最后一个表达式，即sum(x,y)。变量x，y对程序的其它部分不可见。

Scala中赋值动作本身没有值，更准确的说，他们的值是Unit类型的，类似Java中的void，写作();

一个以赋值语句结尾的块，如：{r -=2;n= r+1} 的值是Unit类型的。

语句： x = y =1 //别这么做

y=1的值是(),故x的值是(),相信你的本意不是这样。

输入和输出：

如果需要打印，用print或者println函数，后者打印完成后会追加一个换行符。

print ("hello")

println("world")

等价于 println("hello"+"world"),这个类似Java中的System.out.println("hello"+"world");

循环：

Scala拥有与Java一样的while和do循环。如：

while(n>0) {

r = r*n

n -=1

}

scala没有同java中for(初始化变量;检查变量是否满足条件；更新变量 )对应的循环结构。在Scala中你有两个选择：

1：使用while循环；

2：使用如下for语句;

for(i<- 1 to n)

r = r *i

这个是RichInt类的to方法， 1 to n 这个调用返回数字1到数字n的区间。

for(i <- 表达式)让变量i遍历<-右边的表达式中的所有值。遍历如何执行，取决于表达式的类型。

在for循环的变量之前并没有声明变量为val或者var，该变量的类型是集合的元素类型。循环变量的作用域一直持续到循环结束。

遍历字符串或者数组时，通常使用0到n-1的区间。在Scala中可以用util方法而不是to方法。util方法返回一个并不包含上限的区间。

val s = "hello"

var sum = 0

for(i <- 0 to util s.length)

sum += s(i)

这里i的最后一个取值为s.length-1

注：Scala中没有提供break和continue语句退出循环。

Scala退出循环的方式：

1.使用Boolean类型的控制变量

2.使用嵌套函数--可以从函数中return

3.使用Breaks对象的break方法：

高级for循环和for推导式：

1：使用变量<-表达式形式提供多个生成器，分号分割

2：每个生成器可以带一个守卫，以if开头的Boolean表达式：（if之前没有分号）

3：可以使用任意多的定义，引入可以在循环中使用的变量：

分析：i == 1 时，from=3； j从3 到3 故输出13

i==2 时，from=2；j从2到3，循环两次，故输出22,23

i== 3 时，from=1；j从1到3，循环3此，故输出31 32 33

4：for循环的循环体内已yield开始，则给循环会构造出一个集合，每次迭代生成集合中的一个值，这类循环称为推导式。

其类型是Vector。

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

第一个for循环，第一个类型是 String ；

第二个for循环，第一个类型是Int；

Scala基础之函数：

Scala除了方法，还支持函数。方法对对象进行操作，函数不是。

定义函数，需要给出函数的名称、参数和函数体。如：

def sum(x:int) = if(x>=0) x else -x

函数需要给出所有参数的类型。只要函数不递归，就不需要知道返回列下。Scala可以根据=号右侧表达式推导出放回类型。

如果函数体需要多个表达式完成，可以使用代码块。块的最后一个表达式的值就是函数的返回值。如：

[java] view plaincopy
def sum(n:Int) = {  
  
      for (i <- 1 to 10)   
            r = r*i  
            r  
 }   

此函数r即是函数的返回值。如果使用return返回r的值，那么需要明确指定函数返回类型，如下所示：

[java] view plaincopy
def sum(n:Int):Int = {  
  
      for (i <- 1 to 10)   
            r = r*i  
           return r  
 }    

其与上面的是一样的，只是上面的写法更简洁。

如果是递归函数，同样需要指定返回类型。如：

[java] view plaincopy
def fac(n:Int):Int = if( n <= 0) 1 else n*fac(n-1)  
  
println(fac(5)) //120  

默认参数和代码参数：

有些情况下我们不需要给出全部参数，对应这类函数我们可以使用默认参数，当然你需要知道参数顺序或者参数名称。如：

[java] view plaincopy
def outputBookName(bookname:String,left:String="{",right:String="}") =  
  left + bookname + right  
  
println(outputBookName("book1"))  
  
println(outputBookName("book2", "[", "]"))  
  
println(outputBookName(right="***]",bookname="book3"))  

输出：

{book1} --》使用了默认参数
[book2] --》使用了传入的参数
{book3***] --》根据需要，提供参数名称和值替换默认值

变长参数：

实现一个可以接受可变长度的参数列表的函数，如：

[java] view plaincopy
def sum1(args : Int*) = {  
     var result = 0  
     for(arg <- args)  
        result += arg  
        result  
   }  
     
   println(sum1(5,4,3,2,1)) //15  

实现一个序列作为参数传入上述函数中，需要追加 _*，告诉编译器希望把这个参数当做序列处理。如：

[java] view plaincopy
val s = sum1(1 to 5: _*)  //将1到5当做参数序列处理  

在递归中我们同样可以使用这种方式，如：

[java] view plaincopy
def sum2(args : Int*):Int = {  
      if(args.length == 0 )  
        0  
      else  
        args.head + sum2(args.tail: _*)  
   }  
     

序列的head是参数args的首个元素，而tail是所有其它的元素序列，这是个Seq，需要用 _*将它转为参数序列。

过程：

定义：

Scala对不返回值的函数有特殊的表示法。如果函数体包含在花括号中但没有前面的=号，那么返回类型是Unit。这样的函数叫做过程。

过程不返回值，我们调用它是为了使用它的副作用。如：我们需要打印一些图案，那么可以定义一个过程：

[java] view plaincopy
    def draw(s:String) {  
        
      println("-------")  
      println("|"+"   "+"|")  
      println("|"+s+"|")  
      println("|"+"   "+"|")  
      println("-------")  
    }  
      
    println(draw("123"));  
  
输出：  
  
-------  
|   |  
|123|  
|   |  
-------  
()  

看上面的返回，可以明显的指定这个函数的返回值是Unit；

懒值：

当val被声明为lazy时，它的初始化将被推迟，知道我们首次取它的值。如：

[java] view plaincopy
lazy val file1 = scala.io.Source.fromFile("C:/hello.scala").mkString  
  
println(file1)   

输出：

println("hello")

如果我们不调用

[java] view plaincopy
println(file1)   

这行语句，即file1不被访问，那么文件就不会被打开。

异常：

Scala异常的工作机制同Java。当你需要抛出异常时，如：

throw new FileNotFoundException（"系统找不到指定的文件。"）

Scala异常同Java一样，抛出的异常必须是java.lang.Throwable的子类。其与Java不同的是，Scala没有受检异常，不需要声明函数或者方法可能会抛出异常。

throw 表达式有特殊类型Nothing。这在if else表达式中很有用。如果一个分支的类型是Nothing，那么if else表达式的类型就是另外一个分支的类型。

捕获异常的语法采用模式匹配的语法。如：

try finally语句可以释放资源，不论是否发生异常。如：

[java] view plaincopy
var in = new URL("http://ubmcmm.baidustatic.com/media/v1/0f0000g0bymVB3uhUffi-0.gif").openStream();  
     
   try {  
     process(in)  
   }finally {  
     in.close()  
   }  
     
   def process(in:java.io.InputStream) = {  
       
     println(in.toString());  
       
   }  

输出：sun.net.www.protocol.http.HttpURLConnection$HttpInputStream@8b33e8

以上借鉴http://blog.csdn.net/wangmuming/article/details/35226275

0 0