大数据计算-Scala编程

1.创建一个Person单例，在Person中定义一个List((“xiaoming1”,“男”,18), (“xiaohua1”,“女”,20), (“xiaomeng”,“男”,18), (“xiaoli1”,“女”,19), (“xiaoming2”,“男”,22), (“xiaoli2”,“女”,17), (“xiaoming4”,“男”,28)

(1)把每个人的年龄改成之前的3倍;
(2)过滤年龄小于20的;
(3)过滤别是女的过滤掉;
(4)计算一下所有人的总年龄;
(5)请按照年龄从小到大排序;
(6)请按照年龄从大到小排序;
(7)把每个人的姓名性别年龄合成一个输出;
(8)把年龄为奇数和偶数的人分开

程序代码：

object Person{

  def main(args:Array[String]): Unit = {
    var list = List(("xiaoming1","man",18),("xiaohua","woman",20),("xiaomeng","man",18),("xiaoli1","woman",19),("xiaoming2","man",22),("xiaoli2","woman",17),("xiaoming4","man",28))
    println()

    var res1 = list.map(a  => List(a._1,a._2,a._3 * 3))
    println(res1)
    println()

    var res2 = list.map(a => List(a._1,a._2,a._3 * 2 - 1))
    println(res2)
    println()

    var res3 = list.filter(a => if(a._3 < 20) false else true)
    println(res3)
    println()

    var res4 = list.filter(a => if(a._3.equals( "woman")) false else true)
    println(res4)
    println()
    
    var res5 = list.map(a => a._3).reduce((a,b) => a+b)
    println(res5)
    println()

    list.sortBy(x => x._3).foreach(println)
    println()

    list.sortBy(x => -x._3).foreach(println)
    println()

    var res6 = list.map(a => a._1+a._2+a._3)
    println(res6)
    println()

    var res7 = list.partition({x =>x._3 % 2 == 0})
    println(res7)
  }
}

运行结果：

2. 计算级数

编程计算并输出下列级数的前n项之和Sn，直到Sn刚好大于或等于q为止，其中q为大于0的整数，其值通过键盘输入。

例如，若q的值为50.0，则输出应为：Sn=50.416695。在REPL模式下测试运行，测试样例：q=1时，Sn=2；q=30时，Sn=30.891459；q=50时，Sn=50.416695。

程序代码：

import scala.io.StdIn._
import scala.util.control.Breaks._
import scala.util.{Try, Success, Failure}
 
object project_two {
  def main(args: Array[String]): Unit = {
    breakable {
      //通过一个死循环，加一个循环控制实现连续输入功能
      while (true) {
        println("请输入一个正整数:")
        println("输入q或Q退出......")
        //因为从键盘输入的数据，包括各种类型，为了增加容错，故选用readLine()
        val input = readLine()
        //调用Try类，通过模式匹配实现容错处理
        Try(input.toLong) match {
            //判断输入值是否是正数
          case Success(q) if (q <= 0) =>
            println("请输入一个大于0的正整数。")
          case Success(q) =>
            try {
              //实现级数计算的逻辑
              var sn = 0.0
              var n = 1
              var an = 1.0
              while (sn < q) {
                //通过Math.addExact()函数对数据溢出异常进行处理
                an = Math.addExact(n , 1) / n.toDouble
                sn = sn + an
                n = Math.addExact(n, 1)
              }
              printf("当q=%d, sn=%.6f",q,sn)
              println()
            } catch {
                  //对捕获的异常进行处理
              case _: ArithmeticException =>
                println("计算中发生了溢出异常。请尝试输入较小的正整数。")
              case _: Exception =>
                println("发生了未知异常。")
            }
            //实现程序退出功能
          case Failure(_: NumberFormatException) if input.equalsIgnoreCase("q") =>
            println("程序已退出......")
            break
            //异常处理
          case Failure(_: NumberFormatException) =>
            println("输入无效，请输入一个有效的正整数或q退出。")
          case Failure(exception) =>
            println(s"发生了未知异常：${exception.getMessage}")
        }
      }
    }
  }
}

运行结果：

3. 模拟图形绘制

对于一个图形绘制程序，用下面的层次对各种实体进行抽象。定义一个Drawable的特质，其包括一个draw方法，默认实现为输出对象的字符串表示。定义一个Point类表示点，其混入了Drawable特质，并包含一个shift方法，用于移动点。所有图形实体的抽象类为Shape，其构造函数包括一个Point类型，表示图形的具体位置（具体意义对不同的具体图形不一样）。Shape类有一个具体方法moveTo和一个抽象方法zoom，其中moveTo将图形从当前位置移动到新的位置， 各种具体图形的moveTo可能会有不一样的地方。zoom方法实现对图形的放缩，接受一个浮点型的放缩倍数参数，不同具体图形放缩实现不一样。继承Shape类的具体图形类型包括直线类Line和圆类Circle。Line类的第一个参数表示其位置，第二个参数表示另一个端点，Line放缩的时候，其中点位置不变，长度按倍数放缩（注意，缩放时，其两个端点信息也改变了），另外，Line的move行为影响了另一个端点，需要对move方法进行重载。Circle类第一个参数表示其圆心，也是其位置，另一个参数表示其半径，Circle缩放的时候，位置参数不变，半径按倍数缩放。另外直线类Line和圆类Circle都混入了Drawable特质，要求对draw进行重载实现，其中类Line的draw输出的信息样式为“Line:第一个端点的坐标–第二个端点的坐标)”，类Circle的draw输出的信息样式为“Circle center:圆心坐标,R=半径”。如下的代码已经给出了Drawable和Point的定义，同时也给出了程序入口main函数的实现，请完成Shape类、Line类和Circle类的定义。

程序代码：

//模拟图形绘制
//所有图，用一个接口实现
trait Drawable{
  def draw():Unit={
    println(this.toString)
  }
}
//创建一个点样例类,所有图形都包括点，用一个样例类对点实现封装
case class Point(var x:Double,var y:Double) extends Drawable{
  //点移动方法
  def shift(deltaX:Double,deltaY:Double)={
    x = x + deltaX
    y = y + deltaY
  }
}
//所有图形的父类是抽象类
abstract class Shape(var position:Point){
  //移动
  def moveTo(newPosition:Point)={
    position = newPosition
  }
  //伸缩
  def zoom(scaleFactor:Double):Unit
  override def toString: String = s"Shape:position($position)"
}
//直线类
class Line(start:Point,end:Point) extends Shape(start) with Drawable{
  //末点
  private var endPoint = end
  //移动
  override def moveTo(newPosition:Point):Unit={
    val deltaX = newPosition.x-position.x
    val deltaY = newPosition.y - position.y
    super.moveTo(newPosition)
    endPoint.shift(deltaX,deltaY)
  }
//伸缩
  override def zoom(scaleFactor: Double): Unit = {
    val newEndX = position.x + (endPoint.x - position.x)*scaleFactor
    val newEndY = position.y + (endPoint.y - position.y)*scaleFactor
    endPoint = Point(newEndX,newEndY)
  }
  override def toString:String = s"Line:$position--$endPoint"
 
}
//圆类
class Circle(center:Point,radius:Double) extends Shape(center) with Drawable{
  private var circleRadius:Double=radius//半径
  //伸缩
  def zoom(scaleFactor:  Double): Unit = {
    circleRadius = circleRadius*scaleFactor
  }
  override def toString: String = s"Circle center:$position,R=$circleRadius"
}
object project_three {
  def main(args:Array[String])={
   try{
     //创建一个点对象
     val p = new Point(10,30)
     //输出对象
     p.draw()
     //创建一个直线对象
     val line1 = new Line(Point(0,0),Point(20,20))
     //输出直线对象本身
     line1.draw()
     //将直线移动到Point(5,5)
     line1.moveTo(Point(5,5))
     //输出直线对象的位置
     line1.draw()
     //将直线伸长为原来的两倍
     line1.zoom(2)
     //输出直线对象
     line1.draw()
     //创建一个圆
     val cir = new Circle(Point(10,10),5)
     //输出圆
     cir.draw()
     //移动到点（30，20）
     cir.moveTo(Point(30,20))
     //输出圆的参数
     cir.draw()
     //缩小为原来的一半
     cir.zoom(0.5)
     //输出圆的参数
    cir.draw()
   } catch {
     case ex:Exception => println(s"Exception is ${ex.getMessage}")
   }
  }
}

运行结果：

4. 创建一个ListOperation的单例，在ListOperation中

(1)创建一个名为list的List(6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 1, 2, 3, 4, 5)列表
(2)使用map方法和foreach方法list遍历
(3)将集合内数据+10产生一个新的列表L2
(4)将L2中的所有偶数取出来产生一个新的列表L3
(5)计算L3数据的总和
(6)将L3倒序排序
(7)将L3反转
(8)创建新list1数据为 List(Array(11,22,33), Array(44,55,66))
(9)使用flatten将list1列表合并成一个新的列表
(10)将list奇数偶数分开打印.

程序代码：

object ListOperation{

  def main(args:Array[String]): Unit = {
    var list = List(6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,1,2,3,4,5)
    println()

    list.map(println)
    println()

    list.foreach(println)
    println()

    var L2 = list.map(_ + 10)
    L2.foreach(println)
    println()

    var L3 = L2.filter(x => if(x % 2 ==0) true else false)
    L3.foreach(println)
    println()

    println(L3.reduce((a,b) => a+b))
    println()
    
    println(L3.sortBy(x => -x))
    println()

    println(L3.reverse)
    println()

    var list1 = List(Array(11,22,33),Array(44,55,66))
    list1.foreach(println)
    println()

    var list2 = list1.flatten
    list2.foreach(println)
    println()

    var list3 = list2.partition(x => x%2 == 0)
    list3._1.map(println)
    println()
    list3._2.map(println)
  }
}

运行结果：