spark实验(二)--scala实验(3)

实验1，计算级数：

首先打开安装完scala ide的eclipse，在eclipse 中新建一个scala project。

然后新建一个scala的object对象

导入scala.io.StdIn包，用以实现接受键盘输入

在新建的object对象中，新建main函数，并添加以下代码实现：

package sn
import scala.io.StdIn

object test {
  def main(args: Array[String]): Unit = {
      println("请输入Sn的n值用以计算Sn=2/1+3/2+4/3+...+(n+1)/n来计算Sn的值");
      var q:Int=StdIn.readInt();
      var i:Int=0;
      var sum:Float=0.0f;
      for(i <- 1 to q)
      {
        var id:Float =i;
        sum+=(id+1)/id;
      }
      println("当n="+q+"时,Sn的值为"+sum);
  }
}

运行结果：

实验2，模拟图形绘制

case class Point(var x:Double,var y:Double) extends Drawable{
    def shift(deltaX:Double,deltaY:Double){
        x+=deltaX;
        y+=deltaY
    }
}
trait Drawable{
    def draw()
    {
        println(this.toString)
    }
} 

// 请完成 Shape 类、Line 类和 Circle 类的定义。 

object MyDraw{
    def main(args: Array[String]) {
        val p=new Point(10,30)
                p.draw;
        val line1 = new Line(Point(0,0),Point(20,20))
                line1.draw
                line1.moveTo(Point(5,5))
                //移动到一个新的点
                line1.draw
                line1.zoom(2)
                //放大两倍
                line1.draw
                val cir= new Circle(Point(10,10),5)
                cir.draw
                cir.moveTo(Point(30,20))
                cir.draw
                cir.zoom(0.5)
                cir.draw
    }
} 

其Shape，Line和Circle的定义如下：

abstract class Shape(var startPoint:Point) extends Drawable
{
  def moveTo(newPoint:Point)
  {
    startPoint =newPoint;
  }
  def zoom(num:Double);
}
class Line(x1:Point,var x2:Point) extends Shape(x1)
{
  override def zoom(num:Double)
  {
    val midPoint=Point((x2.x+startPoint.x)/2,(x2.y+startPoint.y)/2)
    startPoint.x=midPoint.x+num*(startPoint.x-midPoint.x)
    startPoint.y=midPoint.y+num*(startPoint.y-midPoint.y)
    x2.x=midPoint.x+num*(x2.x-midPoint.x)
    x2.y=midPoint.y+num*(x2.y-midPoint.y)
  }
  override def moveTo(newPoint:Point)
  {
    var x=(newPoint.x-startPoint.x);
    var y=(newPoint.y-startPoint.y);
    startPoint=newPoint;
    x2.shift(x, y)
  }
  override def draw()
  {
    println(s"Line:(${startPoint.x},${startPoint.y})--(${x2.x},${x2.y})")
  }

}

class Circle(center:Point,var radius:Double) extends Shape(center)
{
  override def draw()
  {
    println(s"Circle center:(${startPoint.x},${startPoint.y}),R=$radius")
  }
  override def zoom(num:Double)
  {
    radius*=num;
  }
}

运行截图：

实验3， 统计学生成绩

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

            // 假设数据文件在当前目录下
            val inputFile = scala.io.Source.fromFile("test.txt")
                    //”\\s+“是字符串正则表达式，将每行按空白字符（包括空格/制表符）分开
                    // 由于可能涉及多次遍历，同 toList 将 Iterator 装为 List
                    // originalData 的类型为 List[Array[String]]
                    val originalData =inputFile.getLines.map{_.split("\\s+")} .toList
                    val courseNames = originalData.head.drop(2) //获取第一行中的课程名
                    val allStudents = originalData.tail // 去除第一行剩下的数据
                    val courseNum = courseNames.length
                    // 统计函数，参数为需要常用统计的行
                    //用到了外部变量 courseNum，属于闭包函数
                    def statistc(lines:List[Array[String]])= {
                            // for 推导式，对每门课程生成一个三元组，分别表示总分，最低分和最高分
                            (for(i<- 2 to courseNum+1) yield {
                                // 取出需要统计的列
                                val temp = lines map {elem=>elem(i).toDouble}
                                (temp.sum,temp.min,temp.max)
                            }) map {case (total,min,max) => (total/lines.length,min,max)
                            } // 最后一个 map 对 for 的结果进行修改，将总分转为平均分
                    }
                    // 输出结果函数
                    def printResult(theresult:Seq[(Double,Double,Double)]){
                        // 遍历前调用 zip 方法将课程名容器和结果容器合并，合并结果为二元组容器
                        (courseNames zip theresult) foreach {
                        case (course,result)=>
                        println(f"${course+":"}%-10s${result._1}%5.2f${result._2}%8.2f${r
                            esult._3}%8.2f")
                        } }
                    // 分别调用两个函数统计全体学生并输出结果
                    val allResult = statistc(allStudents)
                            println("course average min max")
                            printResult(allResult)

                            //按性别划分为两个容器
                            val (maleLines,femaleLines) = allStudents partition
                            {_(1)=="male"}
                    // 分别调用两个函数统计男学生并输出结果
                    val maleResult = statistc(maleLines)
                            println("course average min max")
                            printResult(maleResult)
                            // 分别调用两个函数统计男学生并输出结果
                            val femaleResult = statistc(femaleLines)
                            println("course average min max")
                            printResult(femaleResult)
    }
}