Scala学习笔记-----基本语法和函数

Scala学习笔记1-----基本语法和函数

scala基础

1.数据类型

2.特殊类型说明

3.变量定义

	var定义变量  val定义常量

var i =1
val name="zhangsan"
val xmax, ymax = 100

4 if语句

      if( x == 10 ){
         println("X 的值为 10");
      }else if( x == 20 ){
         println("X 的值为 20");
      }else if( x == 30 ){
         println("X 的值为 30");
      }else{
         println("无法判断 X 的值");
      }
    var a=if (x>10) "1" else "0"

5. for循环语句

	var i=1 to 10 //1到10
    var j=1 until 10 //1到10不包括10
    
      for(i <- 1 to 10)
        for(j<-1 until 10)
          println(i*j)
   //双层循环加守卫
      for (i <- 1 to 3;j <- 1 to 3 if i!=j){
      	print(i*10+j+",")
    }/*output:12,13,21,23,31,32,*/
   //yield关键字将满足条件的值又组合成一个数组
   val result=for(i<- 1 to 10 if(i>5) if(i%2==0))yield i;
      println(result)/*output:Vector(6, 8, 10)*/

6 方法与函数

Scala 有方法与函数，二者在语义上的区别很小。Scala方法是类的一部分，而函数是一个对象可以赋值给一个变量。换句话来说在类中定义的函数即是方法。
（1）Scala 中的方法跟 Java的类似，方法是组成类的一部分。
（2）Scala 中的函数则是一个完整的对象，Scala 中的函数其实就是继承了 Trait 的类的对象。
（3）Scala 中使用 val 语句可以定义函数，def 语句定义方法。
区别：
方法是一个以def开头的带有参数列表（可以无参数列表）的一个逻辑操作块，这正如object或者class中的成员方法一样。
函数是一个赋值给一个变量（或者常量）的匿名方法（带或者不带参数列表），并且通过=>转换符号跟上逻辑代码块的一个表达式。=>转换符号后面的逻辑代码块的写法与method的body部分相同。

方法定义由一个 def 关键字开始，紧接着是可选的参数列表，一个冒号 : 和方法的返回类型，一个等于号 = ，最后是方法的主体。

Scala 方法定义格式如下：

def functionName ([参数列表]) : [return type] = {
   function body
   return [expr]
}

6.1 指定方法参数名

def max(a:Int,b:Int){
    if(a>b)
      a
    else
      b
  }

6.2 递归方法

//递归函数需要显式指明返回类型
def fun(num:Int):Int={
    if(num==1)
       1
    else
      num*fun(num-1)
  }

6.3 可变参数方法

def fun2(s:String*): Unit ={
   for(elem<-s)
    println(elem)
    }

6.4 带有默认值参数的方法

def fun1(a:Int=10,b:Int=20): Int ={
     a+b
  }

6.5 匿名函数

var inc = (x:Int) => x+1
var x = inc(7)-1
//定义多个参数
var mul = (x: Int, y: Int) => x*y
println(mul(3, 4))

6.6 嵌套方法

def out(num:Int): Int ={//嵌套函数
    def in(a:Int)={
      if(a==1)
        1
      else
        a*fun(a-1)
    }
    in(num)
  }

6.7 偏应用函数

Scala 偏应用函数是一种表达式，你不需要提供函数需要的所有参数，只需要提供部分，或不提供所需参数
使用偏应用函数优化方法，绑定第一个 date 参数，第二个参数使用下划线(_)替换缺失的参数列表，并把这个新的函数值的索引的赋给变量

def showLog(date:Date,log:String): Unit ={
    println(s"date is $date,log is $log")
  }
	  val date=new Date()
      showLog(date,"001")
      showLog(date,"002")
def showtime =showLog(date,_:String)//偏应用函数
      showtime("aaa")
      showtime("bbb")

date is Fri Jan 08 22:09:58 GMT+08:00 2021,log is 001
date is Fri Jan 08 22:09:58 GMT+08:00 2021,log is 002
date is Fri Jan 08 22:09:58 GMT+08:00 2021,log is aaa
date is Fri Jan 08 22:09:58 GMT+08:00 2021,log is bbb

6.8 高阶函数

高阶函数（Higher-Order Function）就是操作其他函数的函数。

Scala 中允许使用高阶函数, 高阶函数可以使用其他函数作为参数，或者使用函数作为输出结果。

def count(a:Int,b:Int):Int ={
    a+b
  }
  //方法的参数是方法的方法
  def count1( f:(Int,Int)=>Int,s:String):String={//参数是函数的函数
    val i:Int=f(100,200)
    i+"#"+s
  }
  //方法的返回是函数的方法，需要指明返回类型，加_就可以不显示声明方法的返回类型
  //调用方法是 prints("a")("b","c")
  def prints(s:String)={
    def prints1(s1:String,s2:String):String={
    s+ "*"+s1+"*"+s2
    }
     prints1 _   //"_"相当于指明返回的是什么
  }
  //参数和返回值都是函数的方法
  def spacy(f:(Int,Int)=>Int):(String,String)=>String={
    var i=f(1,2)
    def spacy1(s1:String,s2:String):String={
      s1+"__"+s2+"-"+i
    }
    spacy1
  }

6.9 函数柯里化（是一种高阶函数）

柯里化(Currying)指的是将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数为参数的函数

def kelihua(a:Int,b:Int)(c:Int,d:Int):Int ={
    a+b+c+d
  }
  println(kelihua(1,2)(3,4)) //输出 10