scala 02流程控制 函数

流程控制

if

package com.csg
//流程控制
object scala05 {
  def main(args: Array[String]): Unit = {
    //if 循环跟java一样
    val a=10
    if (a>3){
      println(s"$a> 3")
    }else{
      println(s"$a> 3")
    }
   }    
}

while

 //while 跟java一样
    var b=0
    while (b<5){
      println(s"b = $b")
      //scala 里没有++
      b+=1
    }

for

    // for 循环  步进 类似JAVA for(int i=0 ;i<10;i++) 这种scala中没有
    // 集合循环 类似 for (String a :lista)
    // 1-10的数据放入swqs1
    val seqs1 :Range.Inclusive = 1 to 9
    //1 3 5 7 9 步进是2
    val seqs2 :Range.Inclusive = 1 to (10,2)
    // 1-9
    val seqs3  = 1 until 10
    // for中没有break 但是可以增加守卫，当条件满足 才进去循环
    for (a <- seqs1  if(a%2==1)){
      println(a)
    }

9*9乘法表

 // 9*9 乘法表第一种写法
    for(a <- 1 to 9){
      for(b <- 1 to 9 if(a>=b)){
        print(s"$a * $b = ${a*b}   ")
      }
      println()
    }
 // 9*9 乘法表第二种写法
    var num=0
    for(i <- 1 to 9;j<-1 to 9  ){
      num+=1
      if(i>=j) print(s"$i * $j = ${i*j}   ")
      if(i==j)  println()
    }
    var num1=0
    //优化
 // 9*9 乘法表第三种写法
    for(i <- 1 to 9;j<-1 to 9  if(i>=j)){
      num1+=1
       print(s"$i * $j = ${i*j}   ")
      if(i==j)  println()
    }
    println(num)
    println(num1)

yield

 //yield 收集循环内容 到seqs
    var seqs = for(i <- 1 to 10  ) yield {
      val m=7
      i *7
    }
    println(seqs)

函数

1 普通函数

package com.csg

import java.util

object scala06 {
//普通函数
  def main(args: Array[String]): Unit = {
    }
}

2 递归函数

    //递归函数
    def test5(num :Int): Int ={
      if(num==1){
        num
      }else{
      num * test5(num-1)
      }
    }
    val i :Int= test5(4)
    println(i)

3 默认值函数

    //默认值函数
    def test6(a:Int=5,b:String=""): Unit ={
      println(s"$a ----$b")
    }
    //覆盖
    test6(4,"22")
    //只传一个参数
    test6(b="123")

4 匿名函数

/ 匿名函数
// (Int,Int)=>Int为x的类型 或者叫签名
// (a:Int,b:Int) 为参数， => 表示将参数传递给方法体 ，返回值给x赋值
    var x:(Int,Int)=>Int = (a:Int,b:Int) =>{
      a+b
    }
    val i1 = x(3, 4)
    println(i1)
  }

5 嵌套函数

object scala06 {
  def main(args: Array[String]): Unit = {
        //可以在Scala 里直接调用JAVA类     test3是嵌套函数
        def test3(): util.ArrayList[String] ={
          println(1)
          new util.ArrayList[String]()
        }
    }
}

6 偏应用函数

   //偏应用函数
    def test7(date:Date,tp:String,mes:String): Unit ={
      println(s"当前时间 $date 日志类型 $tp 日志 --$mes")
    }
    //可以直接调用
    test7(new Date(),"error","出错啦！")
    // _ 代表需要传一个参数 并且声明时 方法test7不会执行，因为还没有传入参数
    var error =test7(_,"error",_)
    var info =test7(_,"info",_)
    //使用偏应用函数实现JAVA的多态
    error(new Date,"error类型错误")
    info(new Date,"info类型错误")

7 可变参数

  //可变长度参数 * 代表可以有多个参数
    def test8(a:Int*): Unit = {
      for (a1 <- a) println(a1)

     // def foreach[U](f: A => U): Unit = it match {
      //foreach 接收一个匿名函数为参数  返回一个U类型
      a.foreach( (x:Int)=>{println(x)} )
      //当参数在函数中只出现一次 或者依次出现 可以用_代替。。 如果只有一个参数 还能省略
      a.foreach( println(_) )
      // def println(x: Any): Unit = Console.println(x)
      //println(_) 本身需要一个参数，所以可以直接把函数传进去
      a.foreach( println )

8 高阶函数

   //高阶函数 函数作为参数 函数作为返回值

      //f 是一个函数变量 类型是 传入两个Int参数并返回一个Int
      def test9(a:Int,b:Int,f:(Int,Int)=>Int): Unit = {
        var m = f(a,b)
        println(s"-----$m")
      }
      test9(3,4,(x:Int,y:Int)=>{x+y})
      test9(6,4,(x:Int,y:Int)=>{x-y})
    //当参数依次在匿名函数中出现 可以用_代替。。。
      test9(6,4,_-_)
      //函数作为返回值
    def test10(a:String):(Int,Int)=>Int ={
      def add(b:Int,c:Int): Int ={
        b+c
      }

      if(a.equals("+")){
         add
      }else{
        (x:Int,y:Int)=>{ x-y}
      }
    }
    test9(3,4,test10("+"))

9 柯里化

   //柯里化
    //与test11(a:Int*) 类似，不同点是可以传入多个类型 
    def test11(a:Int)(b:Int)(c:String): Unit ={
      println(s"$a $b $c")
    }
    test11(1)(2)("asd")