登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 资源区 › 代码 ›Scala代码练习

Scala代码练习

悯拄等 4 天前
1、编程实现百分制转换成五级制，规则如下：
90~100分，返回优秀；
80~89分，返回良好；
70~79分，返回中等；
60~69分，返回及格；
60分以下，返回不及格。
  1. object grade {
  2.   def main(args: Array[String]): Unit = {
  3.     val num = 70
  4.     if(num>=90){
  5.       println("优秀")
  6.     }else if(num>=80){
  7.       println("良好")
  8.     }
  9.     else if (num>=70) {
  10.       println("中等")
  11.     }
  12.     else if (num>=60) {
  13.       println("及格")
  14.     }
  15.     else if (num<60) {
  16.       println("不及格")
  17.     }
  18.   }
  19. }
复制代码
11、定义一个函数为wrapHTML，添加前后缀（如和），传递部分参数，打印结果。
  1. object whileTest {
  2.   def main(args: Array[String]): Unit = {
  3.     var num=1
  4.     while(num<=50){
  5.       print(num+" ")
  6.       if(num%5==0){
  7.         println()
  8.       }
  9.       num+=1
  10.     }
  11.   }
  12. }
复制代码
12、应用高阶函数，打印三角形；字符串数组，将其转成大写，再过滤掉以S开头的字符串。实现数字字符串的求和，如 Array("1,2", "3,4") 结果为10。
  1. object jiujiu {
  2.   def main(args: Array[String]): Unit = {
  3.     var i=1
  4.     while(i<=9){
  5.       var j=1
  6.       while(j<=i){
  7.         var ans=i*j
  8.         print(i+"*"+j+"="+ans+" ")
  9.         j+=1
  10.       }
  11.       i+=1
  12.       println()
  13.     }
  14.   }
  15. }
复制代码
13、编写函数values(funInt)=>Int, low:Int, high:Int)，该函数输出一个集合，对应给定区间内给定函数的输入和输出。例如，values(x=>x*x,-5,5)应该产生一个对偶的集合(-5,25),(-4,16),(-3,9),…,(5,25)。
  1. class Rational(val x:Int=10,var y:Int,z:Int=20){
  2.   def sum():Int={
  3.     x+y+z
  4.   }
  5. }
  6. object Rational {
  7.   def main(args: Array[String]): Unit = {
  8.     val r=new Rational(1,2,3)
  9.     println(s"sum1=${r.sum()}")
  10.     val r1=new Rational(y=1)
  11.     println(s"sum2=${r1.sum()}")
  12.     val r2=new Rational(5,y=1,10)
  13.     println(s"sum3=${r2.sum()}")
  14.   }
  15. }
复制代码
15、创建内部类、内部对象以及匿名类，测试使用示例。
  1. object Car {
  2.   def main(arg: Array[String]) {
  3.     var car1 = new Car("BWM", "A6")
  4.     car1.PrintAll()
  5.     var car2 = new Car("BWM", "A6", 2000)
  6.     car2.PrintAll()
  7.     var car3 = new Car("BWM", "A6", "A01")
  8.     car3.PrintAll()
  9.     var car4 = new Car("BWM", "A6", 2000, "A01")
  10.     car4.PrintAll()
  11.   }
  12.   class Car(val producerName: String, val productName: String, val productyear: Int, var num: String) {
  13.     def this(producerName: String, productName: String) {
  14.       this(producerName, productName, -1, "")
  15.     }
  16.     def this(producerName: String, productName: String, productyear: Int) {
  17.       this(producerName, productName, productyear, "")
  18.     }
  19.     def this(producerName: String, productName: String, num: String) {
  20.       this(producerName: String, productName: String, -1, num)
  21.     }
  22.     def PrintAll() {
  23.       println("producerName:" + producerName + " productName:" + productName + " productyear:" + productyear + " num:" + num)
  24.     }
  25.   }
  26. }
复制代码
16、定义一个Logger测试构造器执行顺序造成空指针问题，两种解决方式。
  1. object Student {
  2.   private val secrect1 = "i am secrect1 ******"
  4.   def accessCompanionClass(s: Student) = {
  5.     println(s"access Companion Class private field = ${s.secrect2}")
  6.   }
  7. }
  9. class Student {
  10.   private val secrect2 = "i am secrect2 *****"
  12.   def accessCompanionObject() = {
  13.     println(s"access Companion Object private field = ${Student.secrect1}")
  14.   }
  15. }
  17. object Runl {
  18.   def main(args: Array[String]): Unit = {
  19.     Student.accessCompanionClass(new Student())
  20.     new Student().accessCompanionObject()
  21.   }
  22. }
复制代码
17、设计一个Point类，其x和y坐标可以通过构造器提供，提供一个子类LabelPoint，其构造器接受一个标签值和x、y坐标，比如：
  1. class Point{
  2. var x=1
  3. var y=1
  4. def sum={
  5.    x+y
  6. }
  7. }
  8. object Point{
  9. //当对象（伴生对象）以函数的方式进行调用时，scala 会隐式地将调用改为在该对象上调用apply方法。
  10. def apply(x:Int,y:Int):Point = {
  11.    var p = new Point()
  12.    p.x=x
  13.    p.y=y
  14.    p
  15. }
  16. }
  17. object test{
  18. def main(args: Array[String]): Unit = {
  19.    val p1=Point(3,4)
  20.    val sum1=p1.sum
  21.    print(sum1)
  22. }
  23. }
复制代码
18、提供一个cryptoLogger类，将日志消息以凯撒密码加密，默认密钥为3，不过使用者也可重新传值，提供默认密钥和-3作为密钥时的使用示例。
  1. class teacher(val name:String,val male:String,val age:String,val num:String){
  2. def equals(obj:teacher):Boolean = {
  3.   if(obj.num==this.num){
  4.   true
  5.   }else{
  6.     false
  7.   }
  8. }
  9. }
  10. object teacher{
  11. def main(args: Array[String]): Unit = {
  12.    var a = new teacher("name1", "male1", "age1", "num1")
  13.    var b = new teacher("name2", "male2", "age2", "num1")
  14.    println(a.equals(b))
  15. }
  16. }
复制代码
21、使用不同方式定义可变和不可变数组及多维数组，测试添加元素、删除元素、清空等常用操作。
  1. class teacher(val name:String,val male:String,val age:String,val num:String){
  2. def equals(obj: teacher): Boolean = {
  3.    if (obj.name == this.name&&obj.male == this.male&&obj.age == this.age&&obj.num == this.num) {
  4.      true
  5.    } else {
  6.      false
  7.    }
  8. }
  9. }
  10. object teacher{
  11. def main(args: Array[String]): Unit = {
  12.    var a = new teacher("name1", "male1", "age1", "num1")
  13.    var b = new teacher("name2", "male2", "age2", "num1")
  14.    println(a.equals(b))
  15. }
  16. }
复制代码
24、测试Map键值对的相关操作，有查找映射的最大键或值，按键或值排序，按键或值过滤。
  1. object zero {
  2. def chuFa(a: Int, b: Int): Unit = {
  3.    if (b == 0) {
  4.      println("can not divide by zero")
  5.    }
  6.    else {
  7.      println(a / b)
  8.    }
  9. }
  10. def main(args: Array[String]): Unit = {
  11.    chuFa(3, 0)
  12. }
  13. }
复制代码
25、编写一个函数，接受一个字符串的集合，以及一个从字符串到整数值的映射。返回整型的集合，其值为能和集合中某个字符串相对应的映射的值。举例来说，给定Array ("Tom","Fred","Harry")和Map ("Tom"-> 3,"Dick"-> 4,"Harry"-> 5),返回Array(3,5)。提示：用flatMap将get返回的Option值组合在一起。
  1. object RunWithParFuntion {
  2. def main(args: Array[String]): Unit = {
  3.    val sayhello = () => {
  4.      print("hello scala function")
  5.    }
  6.    exeFuctionWithOutPar(sayhello)
  7.    val plusTen = (i: Int) => {
  8.      i + 10
  9.    }
  10.    exeAdd(plusTen)
  11.    val sum = (x: Int, y: Int) => x + y
  12.    val multi = (x: Int, y: Int) => x * y
  13.    exeAndPrint(sum, 2, 3)
  14.    exeAndPrint(multi, 2, 3)
  15. }
  16. def exeFuctionWithOutPar(callback: () => Unit): Unit = {
  17.    callback()
  18. }
  19. def exeAdd(callback: Int => Int): Int = {
  20.    callback(8)
  21. }
  22. def exeAndPrint(callback: (Int, Int) => Int, x: Int, y: Int): Unit = {
  23.    val result = callback(x, y)
  24.    println(s"callback=$result")
  25. }
  26. }
复制代码
26、测试Scala的模式匹配，模式数据类型有常量、变量、元组、序列、类型、构造器、变量绑定。
  1. class RunPartialFunction {
  2. def warpHTML(pref: String, context: String, suffix: String): String = {
  3.    pref + context + suffix
  4. }
  5. def mutlti(x: Int, y: Int, z: Int) = x * y * z
  6. }
  7. object RunPartialFunction {
  8. def main(args: Array[String]): Unit = {
  9.    val p = new RunPartialFunction()
  10.    val htmlwithp = p.warpHTML("<p>", _: String, "<p>")
  11.    println("p=" + htmlwithp("i am p"))
  12.    val htmlwithdiv = p.warpHTML("", _: String, "")
  13.    println("div=" + htmlwithdiv("i am div"))
  14.    val f1 = p.mutlti(_: Int, 2, _: Int)
  15.    println(f1(4, 5))
  16.    val f2 = p.mutlti(_: Int, 2, 3)
  17.    println(f2(5))
  18.    val f3 = p.mutlti(_: Int, _: Int, _: Int)
  19.    println(f3(5, 1, 2))
  20. }
  21. }
复制代码
27、在Scala中，利用List列表实现归并排序。
  1. object RunHighFun {
  2. def main(args: Array[String]): Unit = {
  3.    val array = Array(1, 2, 3, 4, 5)
  4.    val s = array.map(x => "*" * x)
  5.    array.map("*" * _).foreach(println(_))
  6.    val s2 = Array("scala", "java", "spark")
  7.    s2.map(x => x.toUpperCase).filter(s => (!s.startsWith("S"))).foreach(println(_))
  8.    val sumarrary = Array("1,2", "3,4")
  9.    val sum = sumarrary.flatMap(x => x.split(",")).map(_.toInt).reduce(_ + _)
  10.    println(s"sum=$sum")
  11. }
  12. }
复制代码
28、使用列表制作只在叶子节点存放值的树，举例来说，列表((3 8) 2 (5))描述的是如下这样一棵树，编写一个函数计算所有叶子节点中的元素之和。
+
/ | \

  • 2  +
    /  \    |
    3  8   5
  1. object LowHigh {
  2. def main(args: Array[String]): Unit = {
  3.    val f = (x: Int) => x * x
  4.    val result = values(f, -5, 5)
  5.    result.foreach(println(_))
  6. }
  7. def values(fun: (Int) => Int, low: Int, high: Int): IndexedSeq[(Int, Int)] = {
  8.    for (i <- low to high) yield (i, fun(i))
  9. }
  10. }
复制代码
29、创建RunFunction.scala文件，进行隐式参数和隐式值的演练。
  1. object findMaXdef {
  2. def main(args: Array[String]): Unit = {
  3.    val f = (x: Int) => 10 * x - x * x
  4.    val maxValue = largestValue(f, 1 to 10)
  5.    println(s"maxValue=$maxValue")
  6.    val maxIndex = largestIndex(f, 1 to 10)
  7.    println(s"maxIndex=$maxIndex")
  8. }
  9. def largestValue(fun: (Int) => Int, inputs: Seq[Int]): Int = {
  10.    val result = inputs.map(x => fun(x))
  11.    result.reduce((x, y) =>
  12.      if (x > y)
  13.        x
  14.      else
  15.        y
  16.    )
  17. }
  18. def largestIndex(fun: (Int) => Int, inputs: Seq[Int]): Int = {
  19.    inputs.reduce((x, y) =>
  20.      if (fun(x) > fun(y))
  21.        x
  22.      else
  23.        y
  24.    )
  25. }
  26. }
复制代码
  1. object RunNi {
  2. def main(args: Array[String]): Unit = {
  3.    val p1 = new P("jason", 10) {
  4.      override def print(): Unit = {
  5.        println(s"P($name,$age)")
  6.      }
  7.    }
  8.    p1.print
  9.    println("------------------------------------------")
  10.    val s = new StudentIntenal("scala", 5)
  11.    val grade = new s.Grade("1 grade")
  12.    println(s"grade=${grade.name}")
  13.    s.Uilts1.print("vtil1")
  14.    StudentIntenal.Uilts2.print("util2")
  15.    val pr = new StudentIntenal.printer
  16.    pr.print("printer")
  17. }
  18. }
  19. abstract class P(var name: String, var age: Int) {
  20. def print
  21. }
  22. class StudentIntenal(var name: String, var age: Int) {
  23. class Grade(var name: String)
  24. object Uilts1 {
  25.    def print(name: String) = {
  26.      println(name)
  27.    }
  28. }
  29. }
  30. object StudentIntenal {
  31. class printer {
  32.    def print(name: String) = {
  33.      println(name)
  34.    }
  35. }
  36. object Uilts2 {
  37.    def print(name: String) = {
  38.      println(name)
  39.    }
  40. }
  41. }
复制代码
30、定义一个操作符+%，将一个给定的百分比添加到某个值，举例来说，120 +% 10应得到132。定义一个!操作符，计算某个整数的阶乘，举例来说，5!应得到120。提示：由于操作符是方法，而不是函数，使用隐式类来完成。
  1. import java.io.PrintWriter
  2. object RunFile {
  3. def main(args: Array[String]): Unit = {
  4.    val p = new {
  5.      override val filename = "p052.log"
  6.    }
  7.      with Person051
  8.    p.log("Person052 create log")
  9. }
  10. }
  11. trait Logger {
  12. def log(msg: String)
  13. }
  14. trait FileLogger extends Logger {
  15. val filename: String
  16. val fileout = new PrintWriter(filename)
  17. def log(msg: String) = {
  18.    fileout.println(msg)
  19.    fileout.flush()
  20. }
  21. }
  22. class Person051 extends FileLogger {
  23. override val filename = "p051.log"
  24. }
复制代码
来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
相关推荐
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
悯拄等
4 天前

0

粉丝关注

12

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫