Scala学习笔记(2)

一、控制结构和函数

---------------------------------------------------------------

1、条件表达式

　（1）　在Scala中if/else的表达式都是有值的，这个值就是跟在if或者else之后的表达是的值

　　eg: if(x >0) 1 else -1　　//上面表达式的值是1或者-1，具体是哪个值取决于x的值

　　

　（2）　可以将if/else表达式的值赋给变量

　　val s = if (x > 0) 1 else -1   <===>if(x>0) s = 1 else s =-1　　//相对而言，前面的一种写法会更好，因为其可以用来初始化一个val，而在后面的s必须是var类型，这个地方x是常量不能再进行赋值了

　　java表达式:x>0?1 : -1　　　　//Java或C++  <===>if(x > 0 )1 else -1

　　（3）在Scala中，每个表达式都有一个类型。举例来说，表达式if(x>0) 1 else -1 的类型是Int,因为这里的两个表达式都是Int

　　　　而：if (x>0) "positive" else -1 　　//这个表达式的类型是两个分支类型的公共超类。这里第一个分支是java.lang.String

　　　　而另外一个 分支是Int类型。所以这里的公共超类是Any

　　　　这里如果else部分缺失了：if (x>0) 1　　　　//那么有可能if语句没有输出值。但是在Scal中，每个表达式都应该有某种值，这个问题的解决方案是引入一个Unit类，写作()。

　　　　不带else的if语句等同于if (x> 0 ) 1 else ()　　//()表示的是"无有用值"的占位符，可以将Unit当做Java或C++中的void

　　（4）注意：REPL比起编译器来更加的"近视"，在同一时间只能看到一行代码。

　　　　　　eg: if(x>0) 1

　　　　　　　　else if (x==0) 0 else -1　　　　//这里REPL会执行if(x>0) 1 ，然后就显示结果，而之后看到接下来的　　　　else　　　　关　　　　键　　　　字　　就会不知所措

　　　　如果想在else前面换行的话，需要用到花括号

　　　　if(x > 0){1

　　　　　　} else if (x==0) 0 else -1 

　　　　如果想在REPL中粘贴成块的代码，而又不想近视问题，可以使用粘贴模式。键入:paste，把近视代码粘贴进去，然后按下Ctrl + D。这样REPL会把整个代码块当做一个整体来进行分析

　　(5)条件表达式，scala的表达式有值，是最后一条语句的值

　　　　scala>val x =1 ;

　　　　scala > val b = if (x>0) 1 else -1 ;

　　(6)val xx = if(x>0) 1 else "hello"　　//这个地方的返回值是Any类型　　xx:Any =1，Any是Int和String的创造类

　　　　参数的强转: 1.toString　　　　//将数值类型的转换成字符串类型String类型　　

　　　　　　　　　　"1000".toInt　　　//将字符串类型转换成Int类型

　　(7)赋值语：val y = (s =1 )　　　　//赋值语句为空，y:Unit =()　　类似于java中的void

　　(8)粘贴模式：scala>:paste

　　　　　　　　　　if(x>0) {

　　　　　　　　　　　1　　} else -1

//　　　　　　ctrl + D　　//退出粘贴模式

　　(8)java语言的编码运行过程：*.java ----->*.class----------->程序

2、语句终止：Scala与其他的脚本语言相类似，行尾的位置不需要分号。在}、else以及类似的位置也不需要写分号，只要能从上下文明确的判断出这里是语句的终止就可以

　　(1)如果在单行中能够写下多个语句，就需要用分号将他们分割开来

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

　　(2)如果写较长的语句，需要分成两行来写的话，就需要确保第一行以一个不能用作语句结尾的符号作为结尾，一般来说是比较好的选择是操作符：

　　s = s0 +(v - v0)* t +

　　　　0.5*(a-a0)*t*t

　　(3)Scala程序员们更加倾向于使用花括号来进行相关的处理:

　　　　if(n > 0){

　　　　　　r = r*n

　　　　　　n -=1

　　　　　}　　　　　　//这个地方可以知道，以{结束的行很清楚的表示了后面还有很多的内容

3.块表达式和赋值

　　在java中快语句是包含在{}中的语句序列。当需要在逻辑分支或循环中放置多个动作的时候，可以使用快语句。

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

　　eg:val distance = {val dx = x -x0 ; val dy = y -y0 ; sqrt (dx * dx + dy * dy)}

　　{}块的取值取其最后一个表达式，在此处粗体标出。变量dx和dy仅作为计算所需的中间值

　　在Scala中，赋值动作本身是没有值的，或者说，他们的值是Unit类型的，Unit类型等价于java中的void，而这个类型只有一个值，写作()。一个以赋值语句结束的块，比如{r =r * n; n -=1)的值是Unit类型的

　　　Unit<===>void

4、输入和输出

　　(1).打印一个值，需要用print或者println函数进行相关的打印，而后者在打印完成后会追加一个换行符。

　　　　print("answer:")　　　　//打印

　　　　println(43)　　　　　　//换行打印

　　//输出

　　Scala>print("hellp")

　　Scala>println("hello")

　　Scala>val password = readLine("请输入密码");

5、循环

　　Scala拥有和java相同的while和do循环

　　通过粘贴模式来写循环。(while)

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

通过Scala语言打印出99乘法表

　　

var i = 1;
while(i<10){
  var j = 1;
  while(j<=i){
  print(i+"*"+j+"="+(i*j)+"    ");
  j+=1;          
  }     
  println();
  i+=1;       
}

　　百钱买百鸡问题

//百钱买白鸡
100块钱买100只小鸡
公鸡：5块钱/只
母鸡：3块钱/只
小鸡：1块钱/3只

var cock=0;
while(cock <= 20){
var hen = 0 ;
while(hen <=100/3){
var chicken =0;
while(chicken<=100){
var money=cock*5 + hen*3 +chicken*(1/3);
var mount = cock + hen + chicken;
if(money==100 && mount==100){
println("cock:"+cock+","+"hen:"+hen+","+"chicken:"+chicken);
}
chicken+=3;
}
hen+=1;
}
cock+=1;
}

Scala加载Scala类的方法：load d:scalauy.scala

　　(2)for循环

　　

for(x<-1 to 10) println(x)

语法：
    for(i<- 表达式)    //这个地方1 to n 这个调用返回1到n之间的区间的Range
//让变量i便利<-右边的表达式的所有制。至于这个便利具体如何执行，取决于表达式的类型。

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

　　

val s ="hello"
var sum = 0
for(i <- 0 util s.length){    sum +=s(i)}
println(sum);
　　

可以使用breaks对象的break方法

6、可以使用变量<-表达式的形式提供多个生成器，用分号将其分隔开来。

　　for高级循环

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

　　这个地方每一个生成器都可以带一个守卫，以if开头的Boolean表达式:

　　

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

如果for循环的循环体外面以yield开始，则循环会构造一个集合，每次都迭代集合中的一个值

　　

for(i < -1 to 10) yeild i%3 　　//这样的for循环叫做for循环推倒式

7、函数

Scala除了方法之外还支持函数。方法对对象进行操作，函数不是，如果要定义函数，需要给出函数的名称、参数和函数体

　　

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

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

def fac(n:Int)={
    var r =1
    for(i<- 1 to n) r= r*i
    r
   }

本例中返回值是r，但是没有return 这个关键词

但是对于递归函数，我们必须制定返回值类型。

　　def fac(n:Int):Int=if(n<=0) 1 else n*fac(n-1)　　//这个地方的递归函数必须制定返回值类型，如果没有进行指定，Scala编译器就没有办法校验n*fac(n-1)的数据类型了

　　定义函数：

　　def add (a:Int,b:Int):Int = {

　　　　var c =a+b ;

　　　　return c;

}

在:paste模式下进行粘贴，最后会得到add(a:Int,b:Int)Int，即是参数类型是Int型，返回值类型也是Int型

　　定义递归：

　　def fac(n:Int):Int= if(n==1) 1 else n*fac(n-1);　　　　//定义了n的阶乘，递归的函数必须显示定义返回值类型

　　8.默认参数和带名参数

　　(1)eg:def decorate(str:String,left:String="[",right:String="]")= left+str+right;

　　如果调用decorate("hello")　　===>["Hello"]

　　或者：def decorate(prefix:String,str:String,suffix:String)={　　//默认不带参

　　　　prefix+str+suffix　　　　

　　}

　　//这个地方的调用：最少要带上两个参数,decorate("hello","world");最终把最后的括号带上了

　　//或者指定给哪个参数进行传参,decorate(str="hello")

　　//或者给其他的参数进行相关的传参：scala>decorate(str="hello",prefix="<<"。最后的返回值是<<hello[]]

　　def decorate(prefix:String="[[",str:String,suffix:String="]]")={　　//默认带参数的

　　　　prefix+ str+suffix

　　}

　　调用函数decorate("[[","hello","]]")　==============>[[hello]]

　　(2)如果相对参数的数量的值不够，参数会从后面诸葛应用进来，如decorate("Hello",">>>")会使用right参数的默认值，

　　　得到">>>[Hello]"

def sum(args:Int*)={
    var result = 0
    for(arg <- args) result+=arg
    result
}

　　(3)在提供参数值的时候指定参数名。如：

　　　　decorate(left="<<<",str="Hello",right=">>>")　　　　//最后的结果是<<<Hello>>>

　　(4)带名参数可以让函数更加可读。

　　(5)函数的默认值和命名参数

　　　　scala>def decorate(prefix：String,str:String,suffix:String)={

　　　　　　prefix + str +sufix

　　}

9.变长参数

　（1）边长参数用法例子　

def sum(args:Int*)={
  var result = 0 
  for(arg<-args)  result+=arg
  result          
}

　　val s = sum(1,4,9,16,25)　　//这个地方函数得到的是一个类型为Seq的参数

　　(2)如果已经有一个值的序列，则不能直接将其传入函数。如:var s =sum(1 to 5)　　//错误

　　val s = sum (1 to 5)　　//错误，这个地方要注意，如果sum函数传入的是单个参数，那么参数必须是单个的整数，而不是一个整个的区间。解决的办法是告诉编译器，希望这个参数被当做参数序列进行处理。追加:_*，如下所示：

　　val s =sum(1 to 5:_*)　　//这个地方将1 to 5当做参数序列进行处理

　　(3)在递归定义中会用到上面的语法：

　　　　def recursiveSum(args:Int*):Int={　　　　//在这里序列head是首个元素，而tail是所有其他元素的序列，这又是一个Seq,我们用_*来转换成参数序列

　　　　　　if(args.length==0) 0 

　　　　　　else args.head + recursiveSum(args:tail:_*)

　　}

　　

　　(4)参数当做参数序列进行处理

def sum1(args:Int*):Int={
    if(args.length==0) 0
    else args.head+sum1(args.tail_*)
}

scala>add(1 to 10)　　　　//错误

scala>add(1 to 10:_*)　　//将1 to 10当做序列

10.过程：如果函数体包含在花括号中但是没有前面的=号，那么返回值类型就是Util。这样的函数成为过程

　　　　过程不返回值，我们调用它仅仅是为了副作用

　　　　（1）也可以进行这样的方式进行相关的定义：def box(s:String):Unit={

　　　　　　　　................

　　　　　　}

def box(s:String){    //仔细看：这个地方没有=号
    var border="-" * s.length +"--
"
    println(border+"|"+s+"
"+border)
}

11.懒值

　　当val被声明为lazy的时候，它的初始值将被推迟，知道我们首次对其进行取值

　　lazy val words = 

12.异常处理

　　try{

　　　　"hello".toInt;

　　}catch{

　　　　case _:Exception =>print("xxx");

　　　　case ex:java.io.IOException=>print(ex)

　　}

　　_　　　　　　//通配符

　　java.io._　　　　//通配相当于*

　　:_*　　　　　　//1 to10:_*，转成序列