Scala例题集

单分支双分支

*前边部分题目很简单，为了熟悉scala,练习指感，自己做的，有错误请帮忙指正，3q~!*持续更新

题目1：两Int类型相加，大于50输出hello world 否则输出error

//两Int类型相加，大于50输出hello world 否则输出error
object Hello {
  def main(args: Array[String]): Unit = {
    var a : Int = 1
    var b : Int = 2
    if( (a+b) > 50) println("Hello World") else println("error")
  }
}

题目2：两Double类型,第一个大于10.0且第二个数小于20.0，打印两数之和

object Hello {
  def main(args: Array[String]): Unit = {
  //两Double类型,第一个大于10.0且第二个数小于20.0，打印两数之和
    var a : Double = 11.0
    var b : Double = 2.0
    if( a> 10.0 && b < 20.0) println("a+b="+(a+b))
  }
}

题目3：定义两个变量Int,判断二者之和，是否既能被3又能被5整除，打印提示信息

object Hello {
  def main(args: Array[String]): Unit = {
    //定义两个变量Int,判断二者之和，是否既能被3又能被5整除，打印提示信息
    var a : Int = 11
    var b : Int = 4
    if((a+b)%3==0&&(a+b)%5==0) println("既能被3又能被5整除")
  }
}

题目4：判断一个年份是否是闰年，闰年的条件是否符合以下二者之一：①年份能被4整除，但不能被100整除②能被400整除

object Hello {
  def main(args: Array[String]): Unit = {
    //判断一个年份是否是闰年，闰年的条件是否符合以下二者之一：
    // ①年份能被4整除，但不能被100整除②能被400整除
    var year : Int = 2019
    if((year % 4 == 0 && year%100 != 0 )||( year%400 == 0)) println("闰年") else println("不是闰年")
  }
}

多分支

题目5：求ax2+bx+c=0方程的根。a,b,c分别为函数的参数，如果：b2-4ac>0，则有两个解：
b2-4ac=0,则有一个解；b2-4ac<0，则无解；【a=3 b=100 c=6】
提示1：x1=(-b+sqrt(b2-4ac))/2a
x2=(-b-sqrt(b2-4ac))/2a
提示2：sqrt(sum) 在scala包中（默认引入）的math的包对象有很多方法直接可用

object Hello {
  def main(args: Array[String]): Unit = {
    val a : Double = 3
    val b : Double = 100
    val c : Double = 6
    val num = b*b-4*a*c
    var x1 =0.0
    var x2 =0.0
    if(num > 0){
        x1=(-b+sqrt(b*b-4*a*c))/2*a
        x2=(-b-sqrt(b*b-4*a*c))/2*a
      println("两个解分别为：" + x1.formatted("%.2f") + "和" + x2.formatted("%.2f"))
    }else if (num == 0){
        x1=(-b+sqrt(b*b-4*a*c))/2*a
      println("一个为：" + x1.formatted("%.2f"))
    }else println("无解")
    }
}

递归

说明：
递归不能使用类型推断，无法推断出结果，使用时必须指定返回值类型

斐波那契数列

**题目6：**斐波那契1,1,2,3,5,8,13，给你一个整数n，求斐波那契数，第几个斐波那契

object Hello {
  def main(args: Array[String]): Unit = {
    //斐波那契1,1,2,3,5,8,13，给你一个整数n，求斐波那契数，第几个斐波那契
    println(getRes(7))
  }

  def getRes(n: Int): Int = {
    if (n == 1) {
      1
    } else if (n == 2) {
      1
    }
    else {
      getRes(n - 1) + getRes(n - 2)
    }
  }
}

求函数值

题目7求函数值，已知f(1)=3; f(n) = 2*f(n-1)+1

object Hello {
  def main(args: Array[String]): Unit = {
    //求函数值，已知f(1)=3; f(n) = 2*f(n-1)+1
    println(getRes(7))
  }
  def getRes(n: Int): Int = {
    if (n == 1) {
      3
    }
    else {
      2*getRes(n-1)+1
    }
  }
}

猴子吃桃

题目8： 猴子吃桃子，第一天吃了一半，并多吃一个，以后每天都吃一半，并多吃一个，
到第十天，只有一个桃子。问第一天没吃时有几个桃子？

object Hello {
  def main(args: Array[String]): Unit = {
    println(getRes(1))
  }
  def getRes(n: Int): Int = {
    if (n == 10) {
      1
    }
    else {
      (getRes(n+1)+1)*2
    }
  }
}

数据类型

例子：形参列表和返回值列表的数据类型可以是值类型和引用类型

object Hello {
  def main(args: Array[String]): Unit = {
    val tiger = new Tiger
    val tiger2 = test01(10,tiger)
    println(tiger2.name)//tiger

    println(tiger.name)//tiger

    println(tiger.hashCode())//两hashCode相等
    println(tiger2.hashCode())//两hashCode相等
  }

  def test01(n : Int,tiger:Tiger): Tiger = {//如果这里没有写Tiger返回值，是默认的，下面的tiger就会无效
    println(n)
    tiger.name="tiger"
    tiger//返回省略return
  }

  class Tiger{
    var name = "xx"
  }

}

• 疑问：说方法中调用方法，如何调用，点也点不出

object Hello {
  def main(args: Array[String]): Unit = {
    def f1:Unit={
      println("f1")
    }
    println("ok~~~")

    def sayOk():String ={
      def sayOk:String ={
        return  "sayOk sayOk"//这个怎么输出？？？？
      }
      return "main main sayOk"
    }

    Hello.sayOk()//main sayOk
    println(sayOk())//main main sayOk

  }

  def sayOk():Unit ={
    println("main sayOk")
  }

}

可变参数

object Hello {
  def main(args: Array[String]): Unit = {
    println(sum(10, 30, 10, 2))
  }

  def sum(n1: Int,args:Int*):Int ={
    println("args.length"+args.length)
    var sum = n1
    for (i <- args){
      sum+=i
    }
    sum
  }

结果：
args.length3
52

惰性函数

需要的时候提供其元素，无需预先计算
懒汉就是这种模式
注意：lazy不能修饰var

object Hello {
  def main(args: Array[String]): Unit = {
    lazy val res = sum(10,50,10,2)
    println(res)//这里才执行，上面不会执行
  }

  def sum(n1: Int,args:Int*):Int ={
    println("args.length"+args.length)
    var sum = n1
    for (i <- args){
      sum+=i
    }
    sum
  }
}

异常

scala中异常思想为模式匹配（case）类似switch，也可以通过throw抛异常
case异常例子

object Hello {
  def main(args: Array[String]): Unit = {
    try {
      val r = 10 / 0
    } catch {
      case ex:Exception => {
        //在java中是不允许把大的异常放在小异常的前面，scala却可以，但是并没啥用
        //正常情况还是要用ArithmeticException放在前头
        println("大异常")}
      case ex:ArithmeticException => {
        println("小异常")}
    } finally {
        println("不管怎么样我都要抛异常")
    }
  }
}

throw异常例子

object Hello {
  def main(args: Array[String]): Unit = {
    res(10,0)
  }

  @throws (classOf[ArithmeticException])//加了没加输出都是一样，仅声明异常
  def res(a:Int,b:Int): Any ={
    return a/b
  }
}

金字塔

第一种方式:

object Hello {
  def main(args: Array[String]): Unit = {
    //打印金字塔
    pyramid(9)
  }
   def pyramid(n : Int) ={
     for (i<- 1 to n){
       print(" "*(n-i))
       print("*"*(2*i-1))
       println()
     }
   }
}

第二种方式：

object Hello {
  def main(args: Array[String]): Unit = {
    //打印金字塔
    pyramid(9)
  }

   def pyramid(n : Int) ={
     for (i<- 1 to n){
       for (j<- 1 to (n-i)){
         print(" ")
       }
       for (j<- 1 to (2*i-1)){
         print("*")
     }
         println()
   }
}
}

结果：

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

九九乘法表

object Hello {
  def main(args: Array[String]): Unit = {
    //打印九九乘法表
    for(i <- 1 to 9){
      for (j <- 1 to i){
        printf("%d*%d=%d\t",j,i,j*i)
      }
      println()
    }
  }
}

结果

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

foreach

题目：编写一个for循环,计算字符串中所有字母的Unicode代码（toLong方法）的乘积。举例来说，"Hello"中所有字符串的乘积为9415087488L

//第一种方法
  var t:Long =1
    "Hello".foreach(t *= _.toLong)
    println(t)
//第二种方法
  var t:Long =1
  for(i <- "Hello"){
  t *= i.toLong
  }
  println(t)
//第三种方法
def product(s:String):Long ={
if(s.length==1){
return s.charAt(0).toLong
}else{
return s.take(1).charAt(0).toLong*product(s.drop(1))
//var a = "Hello"
//println(a.take(1))\\H
//println(a.charAt(0))\\H
//println(a.drop(1))\\ello
}
}