2020.10.19~21课堂笔记(初识scala,scala函数)

最新推荐文章于 2023-02-25 17:30:27 发布

超可爱慕之

最新推荐文章于 2023-02-25 17:30:27 发布

阅读量210

点赞数

分类专栏：笔记

本文链接：https://blog.csdn.net/m0_48758256/article/details/109199839

版权

笔记专栏收录该内容

138 篇文章 5 订阅

订阅专栏

在scala中实现打印从10到3：

1.使用breakable-break的方式跳出循环

导入的类是：import scala.util.control.Breaks._

object demo2 {
 def main(args:Array[String]):Unit = {
   import scala.util.control.Breaks._
   var num=10
   breakable{
     /*for(x <- num to 1 by -1){
       if(x<3) break
       print(x+"\t")
     }*/
     for(x<- num to 1 by -1 if x>=3 ) print(x+"\t")
   }
 }
}

2.使用loop.breakable-loop.break的方式跳出循环

导入的类是：import scala.util.control.Breaks

object demo2 {
 def main(args:Array[String]):Unit = {
 
   import scala.util.control.Breaks
   val num=10
   val loop = new Breaks
   loop.breakable(
     for(x <- num to 3 by -1){
       if(x<3) loop.break
       print(x+"\t")
     }
   )
   
 }
}

使用变量接收循环语句的结果集合（yield关键字），遍历集合

object demo2 {
 def main(args:Array[String]):Unit = {
 
   var i=100;
   val resValue=for(x<-1 to i ; if x%2==0;if x%5==0) yield x
   println(resValue)
   println("-------------------")
   for(i <- resValue){
     print(i+"\t")
   }
   
 }
}

结果显示：

Vector(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
-------------------
10	20	30	40	50	60	70	80	90	100	
Process finished with exit code 0

if流程控制：

判断i的值和10的大小关系，打印

object demo2 {
 def main(args:Array[String]):Unit = {
 
   val i=10
   if(i>10){
     println(i+"的值大于10")
   }else if(i==10){
     println(i+"的值等于10")
   }else{
     println(i+"的值小于10")
   }

 }
}

练习：判断i的值和10是否相等，相等加1，不相等加2，并打印

object demo2 {
 def main(args:Array[String]):Unit = {

   val i=10
   val j=if(i==10) i+1 else i+2
   println(j)
   
 }
}

定义代码块：

代码块的结果是在代码块中计算的最后一行

object demo2 {
 def main(args:Array[String]):Unit = {

   val x=10
   val y={
     print("代码块\t")
     x+1
   }
   println(y)

   println("---------------")

   val y2={
     x+1;println("代码块")
   }
   println(y2)
   
 }
}

打印结果：

代码块	11
---------------
代码块
()

Process finished with exit code 0

循环语句

在for循环中：
1 to 10 可以取到10
1 until 10 取不到10

object demo2 {
  def main(args:Array[String]):Unit = {

    var x=0
    println("-------while循环------")
    while(x<10){
      print(x+"\t")
      x+=1
    }
     x=0
    println("\n-------do-while循环------")
    do{
      print(x+"\t")
      x+=1
    }while(x<10)
    println("\n-------for循环(1 to 10)------")
    for(x <- 1 to 10) print(x+"\t")
    println("\n-------for循环(1 until 10)------")
    for(x <- 1 until 10) print(x+"\t")
    
  }
}

打印结果：

-------while循环------
0	1	2	3	4	5	6	7	8	9	
-------do-while循环------
0	1	2	3	4	5	6	7	8	9	
-------for循环(1 to 10)------
1	2	3	4	5	6	7	8	9	10	
-------for循环(1 until 10)------
1	2	3	4	5	6	7	8	9	
Process finished with exit code 0

练习：使用循环打印九九乘法口诀表

外层循环速度慢，内层循环速度快

object demo2 {
  def main(args:Array[String]):Unit = {

    for(x<-1 until 10){
      for (y<-1 to x){
        print(s"$x*$y=${x*y}\t")
      }
      println()
    }

  }
}

打印结果：

1*1=1	
2*1=2	2*2=4	
3*1=3	3*2=6	3*3=9	
4*1=4	4*2=8	4*3=12	4*4=16	
5*1=5	5*2=10	5*3=15	5*4=20	5*5=25	
6*1=6	6*2=12	6*3=18	6*4=24	6*5=30	6*6=36	
7*1=7	7*2=14	7*3=21	7*4=28	7*5=35	7*6=42	7*7=49	
8*1=8	8*2=16	8*3=24	8*4=32	8*5=40	8*6=48	8*7=56	8*8=64	
9*1=9	9*2=18	9*3=27	9*4=36	9*5=45	9*6=54	9*7=63	9*8=72	9*9=81

使用循环打印等腰三角形：

object demo2 {
  def main(args:Array[String]):Unit = {
  
    val num=5
    for(i<-1 to num){
      for (j<-num to i  by -1){
        print(" ")
      }
      for(k<-1 to 2*i-1) print("*")
      println()
    }

  }
}

显示结果：

     *
    ***
   *****
  *******
 *********

Process finished with exit code 0

练习：打印一个中间掏空的等腰三角形

在原来等腰三角形的基础上，第一行和最后一行要正常打印，其余每一行只打印第一个*和最后一个*其余打印空格

object demo2 {
  def main(args:Array[String]):Unit = {
    val num=5
    for(i<-1 to num){
      for (j<-num to i  by -1){
        print(" ")
      }
      for(k<-1 to 2*i-1){
        if(i==1 || i==num || k==1 ||k==2*i-1) print("*") else print(" ")
      }
      println()
    }

  }
}

打印结果：

     *
    * *
   *   *
  *     *
 *********

Process finished with exit code 0

元组

与列表一样，元组也是不可变的，但与列表不同的是元组可以包含不同类型的元素。

元组的值是通过将单个的值包含在圆括号中构成的。

object demo3 {
  def main(args:Array[String]):Unit ={
  
    var tupleDemo=("hello","kb09",1.2,3,"world","a")
    println(tupleDemo)
    println("tupleDemo._1的值："+tupleDemo._1)
    println("tupleDemo._2的值："+tupleDemo._2)
    println("tupleDemo._3的值："+tupleDemo._3)
    println("tupleDemo._4的值："+tupleDemo._4)
    println("tupleDemo._5的值："+tupleDemo._5)
    println("tupleDemo._6的值："+tupleDemo._6)
    
  }
}

元组的遍历方式

tupleDemo.productIterator.foreach(println)
tupleDemo.productIterator.foreach(x=> println(s"value:$x"))

显示结果：

value:hello
value:kb09
value:1.2
value:3
value:world
value:a

元组的定义方式

var tupleDemo2 = new Tuple5("ab","bc","cd","de","ef")

或者：

object demo3 {
  def main(args:Array[String]):Unit ={

    def mike="mike"->5->6
    println(mike._1)
    println(mike._2)
    println(mike.getClass)

  }
}

显示结果：
mike的类型是：Tuple2 ((String,Int),Int)

(mike,5)
6
class scala.Tuple2

Process finished with exit code 0

object demo3 {
  def main(args:Array[String]):Unit ={

    val tp1=("zhangsan","nanjing",19)
    val(name,address,age)=tp1
    println(s"姓名：$name，地址：$address，年龄：$age")

  }
}

显示结果：

姓名：zhangsan，地址：nanjing，年龄：19

数组的定义

object demoArray {
  def main(args:Array[String]):Unit={
    
    var arr:Array[String]=new Array[String](3)
    arr(0)="hello"
    arr(1)="world"
    arr(2)="scala"
    println(arr(0))
    println("--------arr2--------")
    var arr2=Array("kb09","luoxin","gree")
    println(arr2(1))
    
  }
}

显示结果：

hello
--------arr2--------
luoxin

函数的定义和使用

object FunctionDemo {
  def main(args:Array[String]):Unit={
    
    //函数的定义和使用
    //输入两个整数返回较小数的值
    def minValue(a:Int,b:Int):Int=if(a>b) b else a
    //输入两个整数和符号，如果是加号则求和，其余求差
    def sumValue(a:Int,b:Int,c:String):Int=if(c.equals("+")) a+b else a-b

  }
}

使用递归的方式写出阶乘

object FunctionDemo {
  def main(args:Array[String]):Unit={

    //阶乘
    def jiecheng(a:Int):Int={
      if(a==1){
        a
      }else{
        a*jiecheng(a-1)
      }
    }
    println(jiecheng(8))

  }
}

通过指定参数名字，传递参数值

object FunctionDemo {
  def main(args:Array[String]):Unit={
  
    def showMsg(name:String,age:Int):Unit={
      println(s"hello:$name,age:$age")
    }
    //按照参数顺序传递参数
    showMsg("zhangsan",18)
    //通过指定参数名字，传递参数值
    showMsg(age=18,name="zhangsan")
  
  }
}

参数的长度未知，通过*来表示，可以传入多个参数

object FunctionDemo {
  def main(args:Array[String]):Unit={

    //参数的长度未知，通过*来表示，可以传入多个参数
    def showMsg2(name:String,s:String*)={
      println(name)
      for(str<-s){
        println(str)
      }
    }
    showMsg2("kb09","abc","hello")
    
  }
}

匿名函数

object FunctionDemo {
  def main(args:Array[String]):Unit={

    def sum(a:Int,b:Int):Int=a+b
    //匿名函数
    val aa = (a:Int,b:Int) => a+b
    println("aa(32,31)的结果为"+aa(32,31))
    val bb=aa
    println("bb(66,88)的结果为"+bb(66,88))
    val cc=(a:Int,b:Int)=>"abc"
    println("cc(11,22)的结果为"+cc(12,21))

    val sum1:(Int,Int)=>Int = (a:Int,b:Int)=>a+b
    val sum2:(Int,Int)=>Int =        aa
    println("sum1(1,3)的结果为"+sum1(1,3))
    println("sum2(12,23)的结果为"+sum2(12,23))

  }
}

显示结果：

aa(32,31)的结果为63
bb(66,88)的结果为154
cc(11,22)的结果为abc
sum1(1,3)的结果为4
sum2(12,23)的结果为35

函数作为参数进行传递

object FunctionDemo {
  def main(args:Array[String]):Unit={

    //函数作为参数进行传递
    def fun(a:Int,b:Int):Int =a+b
    def fun1(a:Int,b:Int):Int=a-b
    def fun2(a:Int,b:Int):Int=a*b

    def funTest(f:(Int,Int)=>Int,s:String):String={
      val resultValue=f(1000,3000)
      s+resultValue
    }

    var resultValue=funTest(fun,"你的薪水是：")
    println(resultValue)

    println("-----使用匿名函数作为参数传递-----")

    resultValue=funTest((a:Int,b:Int)=>a+b,"您的薪水是：")
    println(resultValue)

  }
}

显示结果：

你的薪水是：4000
-----使用匿名函数作为参数传递-----
您的薪水是：4000

函数作为返回值

object FunctionDemo {
  def main(args:Array[String]):Unit={

    //函数作为返回值
    //不传参数，返回一个签名是 (String,String)=>String 的函数
    def funTest2():(String,String)=>String={
      def fun2(str1:String,str2:String):String={
        str1+"##"+str2+"&&"
      }
      fun2
    }
    println(funTest2()("aa", "bb"))

  }
}

显示结果：

aa##bb&&

练习：先传递一个字符串，如果长度大于5，传递两个整数相加，如果字符串长度小于5，传递两个整数相减，如果字符串长度等于5，传递两个整数相乘

object FunctionDemo {
  def main(args:Array[String]):Unit={

    //先传递一个字符串，如果长度大于5，传递两个整数相加
    //如果字符串长度小于5，传递两个整数相减
    //如果字符串长度等于5，传递两个整数相乘
    def funTest2(s:String):(Int,Int)=>Int={
      if(s.length>5){
        def funAdd(a:Int,b:Int):Int= a+b
        funAdd
      }else if(s.length<5){
        def funMinus(a:Int,b:Int):Int=a-b
        funMinus
      }else{
        def funMultiply(a:Int,b:Int):Int=a*b
        funMultiply
      }
    }
    val intValue = funTest2("Hello")(100,200)
    println(intValue)

  }
}

练习：传入一个数字，如果能被3整除，返回加法，否则返回减法

object FunctionDemo {
    def main(args:Array[String]):Unit={

      //传入一个数字，如果能被3整除，返回加法，否则返回减法
      def getFunByNum(num:Int):(Int,Int)=>Int ={
        if(num%3==0){
          (a:Int,b:Int)=>a+b
        }else{
          (a:Int,b:Int)=>a-b
        }
      }
      println(getFunByNum(4)(100, 200))

  }
}

函数作为参数传递进来，函数作为返回值返回出去

相同需求改进练习：传入一个数字，如果能被3整除，返回加法，否则返回减法

object FunctionDemo {
  def main(args:Array[String]):Unit={

    //函数作为参数传递进来，函数作为返回值返回出去
    //传入一个数字，如果能被3整除，返回加法，否则返回减法
    def funMsg(f:(String)=>Int,str:String):(Int,Int)=>Int ={
      val intNum=f(str)
      if(intNum%3==0){
        (a:Int,b:Int)=>a+b
      }else{
        (a:Int,b:Int)=>a-b
      }
    }

    val resultNum = funMsg(
      (a: String) => {if (a.equals("上海")) 3 else 1}, "上海")(100, 500)
    println(resultNum)
  }
}

练习：先传入一个数字，判断是否能被3整除，再传入两个整数，进行两数相加/相减，判断结果值是否大于3000，再传递字符串，打印不同的打印语句

object FunctionDemo {
  def main(args:Array[String]):Unit={
    //传入一个数字，判断除以3是否等于0，如果等于0相加，但是不返回两个数相加的和，
    // 如果金额大于3000，传一个名字进来，再返回一个空函数，打印一句话
    def funTest3(a:Int):(Int,Int)=>(String)=>Unit ={
      if(a%3==0){
        def funAdd(a:Int,b:Int):(String)=>Unit ={
          if(a+b>3000){
            (x:String) => {
              println("恭喜"+x+"你的收入很高")
            }
          }else{
            (x:String) => {
              println("很遗憾"+x+"再加把力")
            }
          }
        }
        funAdd
      }else{
        def funMinus(a:Int,b:Int):(String)=>Unit ={
          if(a-b>3000){
            (x:String)=>{
              println(x+"你是一个非常节约的人")
            }
          }else{
            (x:String)=>{
              println(x+"????你已经入不敷出了")
            }
          }
        }
        funMinus
      }
    }
    funTest3(7)(5000,7000)("zhangsan")
  }
}

函数柯理化

object FunctionDemo {
  def main(args:Array[String]):Unit={

    //函数柯里化
    def fun(a:Int,b:Int,c:Int,d:Int):Int={a+b+c+d}
    def fun1(a:Int,b:Int)(c:Int,d:Int):Int={a+b+c+d}
    def fun2(a:Int)(b:Int)(c:Int)(d:Int):Int={a+b+c+d}
    def fun3(a:Int,b:Int,c:Int)(d:Int):Int={a+b+c+d}
    def fun4(a:Int)(b:Int,c:Int,d:Int):Int={a+b+c+d}

    println(fun(1, 2, 3, 4))
    println(fun1(1, 2)(3, 4))
    println(fun2(1)(2)(3)(4))
    println(fun3(1, 2, 3)(4))
    println(fun4(1)(2, 3, 4))

  }
}

隐式参数

object FunctionDemo {
  def main(args:Array[String]):Unit={

    //隐式参数  同一个类型再一个作用域只能有一个
    implicit var a:Int=10
    implicit var str:String="hello"
    def fun5(a:Int,b:Int)(c:Int=5):Int={a+b+c}
    def fun6(a:Int,b:Int)(implicit c:Int=5):Int={a+b+c}
    def fun7(a:Int,b:Int)(implicit c:Int=5,str:String):Int={
      println(str)
      a+b+c
    }
    //优先级：传参 > 隐式函数 > 默认值
    println("fun5(10, 10)()的结果是："+fun5(10, 10)())
    println("fun6(10,10)(20)的结果："+fun6(10,10)(20))
    println("fun6(10, 10)的结果："+fun6(10, 10))
    println("fun6(10,10)()的结果"+fun6(10,10)())
    println("fun7(10,10)的结果"+fun7(10,10))
    println("fun7(10,10)(c=123,str=\"abc\")的结果是:"+fun7(10,10)(c=123,str="abc"))
    
  }
}

显示结果：

fun5(10, 10)()的结果是：25
fun6(10,10)(20)的结果：40
fun6(10, 10)的结果：30
fun6(10,10)()的结果25
hello
fun7(10,10)的结果30
abc
fun7(10,10)(c=123,str="abc")的结果是:143

模式匹配和样例类

object demoMatch {

  def method1(x:Int):String={
    if(x==1){
      "one"
    }else if(x==2){
      "two"
    }else{
      "many"
    }
  }

  //模式匹配：值
  def match1(x:Int):String=x match{
    case 1 => "one"
    case 2 => "two"
    case _ => "many"
  }

  //模式匹配类型：
  def match2(x:Any):Unit=x match{
    case 1 => println("输入的值是1")
    case i:Int => println("输入的值类型为Int类型，值为"+i)
    case s:Int => println("输入的值类型为String类型，值为"+s)
    case _ => println("我不知道是啥")
  }

  //样例类
  case class Teacher(name:String,age:Int)

  def match3(teacher:Teacher):Unit=teacher match{
    case Teacher("gree",19) => println("hello gree")
    case Teacher("wenwen",21) => println("hello wenwen")
    case x:Teacher =>{println("hello"+x.name)}
  }

  def main(args: Array[String]): Unit = {
    println(match1(2))
    match2(1)
    val t=Teacher("gree",19)
    val t1=Teacher("gree",19)
    if(t==t1){
      println("是同一个人")
    }else{
      println("不是同一个人")
    }
    match3(t)

  }
}

显示结果：

two
输入的值是1
是同一个人
hello gree

超可爱慕之

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
2020.10.19~21课堂笔记(初识scala,scala函数)

在scala中实现打印从10到3：1.使用breakable-break的方式跳出循环导入的类是：import scala.util.control.Breaks._object demo2 { def main(args:Array[String]):Unit = { import scala.util.control.Breaks._ var num=10 breakable{ /*for(x <- num to 1 by -1){ if(x&lt
复制链接

扫一扫