学习笔记五——scala基础学习与spark实验二

　　今天继续学习了scala的一些知识，比如类与对象，抽象类等，还完成了spark实验二。　　

　　scala基础

　　（1）迭代器：迭代器（Iterator）不是一个集合，但是，提供了访问集合的一种方法。它包含两个函数：hasNext与next；hasNext可以判断迭代器是否还有下一个元素，next可以返回迭代器的下一个元素。

　　　while循环

　　　

　　　for循环

　　　

　　（2）class定义类，def定义方法

　　　　方法定义格式：def 方法名（参数名:参数类型）: 返回值类型 = {函数体}

　　　　主构造器与辅助构造器：

　　　　主构造器是定义类时，类名后面标识参数类型与名称：

class Counter(val name: String, val mode: Int) {
    private var value = 0 //value用来存储计数器的起始值    
    def increment(step: Int): Unit = { value += step}
    def current(): Int = {value}
    def info(): Unit = {printf("Name:%s and mode is %d
",name,mode)}
}
object MyCounter{
    def main(args:Array[String]){       
        val myCounter = new Counter("Timer",2)
        myCounter.info  //显示计数器信息
        myCounter.increment(1)  //设置步长  
        printf("Current Value is: %d
",myCounter.current) //显示计数器当前值       
    }
}

 　　　　辅助构造器是想java一样，在类内部实现，但是名称不是使用类名，而是this：

class Counter {
    private var value = 0 //value用来存储计数器的起始值
    private var name = "" //表示计数器的名称
    private var mode = 1 //mode用来表示计数器类型（比如，1表示步数计数器，2表示时间计数器）
    def this(name: String){ //第一个辅助构造器
        this() //调用主构造器
        this.name = name
    }
    def this (name: String, mode: Int){ //第二个辅助构造器
        this(name) //调用前一个辅助构造器
        this.mode = mode
    }
    def increment(step: Int): Unit = { value += step}
    def current(): Int = {value}
    def info(): Unit = {printf("Name:%s and mode is %d
",name,mode)}
}
object MyCounter{
    def main(args:Array[String]){
        val myCounter1 = new Counter  //主构造器
        val myCounter2 = new Counter("Runner") //第一个辅助构造器，计数器的名称设置为Runner，用来计算跑步步数
        val myCounter3 = new Counter("Timer",2) //第二个辅助构造器，计数器的名称设置为Timer，用来计算秒数
        myCounter1.info  //显示计数器信息
        myCounter1.increment(1)     //设置步长  
        printf("Current Value is: %d
",myCounter1.current) //显示计数器当前值
        myCounter2.info  //显示计数器信息
        myCounter2.increment(2)     //设置步长  
        printf("Current Value is: %d
",myCounter2.current) //显示计数器当前值
        myCounter3.info  //显示计数器信息
        myCounter3.increment(3)     //设置步长  
        printf("Current Value is: %d
",myCounter3.current) //显示计数器当前值

    }
}

　　　　getter与setter的使用方法

　　　　其实scala中也是险恶getter与setter方法的功能，但是没有定义为getter与setter：

class Counter {
    private var privateValue = 0  //变成私有字段，并且修改字段名称
    def value = privateValue //定义一个方法，方法的名称就是原来我们想要的字段的名称
    def value_=(newValue: Int){
        if (newValue > 0) privateValue = newValue //只有提供的新值是正数，才允许修改
    }
    def increment(step: Int): Unit = { value += step}
    def current(): Int = {value}
}

　　（3）特质(trait)

　　　Scala中，一个类只能继承自一个超类，却可以实现多个特质，从而重用特质中的方法和字段，实现了多重继承。

　　　特质跟继承不一样，特质可以包含非抽象字段或方法，一个类混入第一个特质使用extends，之后再混入使用with，例如：

class BYDCarId extends CarId with CarGreeting{ //使用extends关键字混入第1个特质，后面可以反复使用with关键字混入更多特质
     override var id = 10000 //BYD汽车编号从10000开始
     def currentId(): Int = {id += 1; id} //返回汽车编号
 }

　　spark基础实验二 　　　　

　　　　题目1：

　　　　

　　　　源码：　　

import io.StdIn._

object test{
    def main(args:Array[String]){
    var Sn:Float = 0
    var n:Float = 1
    print("请输入q：")
    val q = readInt();
    while(Sn<q){
        Sn += (n+1)/n
        n += 1
    }
    println("Sn="+Sn)
    }
}   

　　　　结果：

　　　　

　　　　题目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 类的定义。
    abstract class Shape(var location:Point){//location是Shape的一个可变字段
    def moveTo(newLocation:Point){ //默认实现，只是修改位置
        location = newLocation
        }
     def zoom(scale:Double)
    }
  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
        }
    }
    

　　　　完整代码：

    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 类的定义。
    abstract class Shape(var location:Point){//location是Shape的一个可变字段
    def moveTo(newLocation:Point){ //默认实现，只是修改位置
        location = newLocation
        }
     def zoom(scale:Double)
    }
    class Line(beginPoint:Point,var endPoint:Point) extends Shape(beginPoint) with Drawable{
    override def draw(){
        println("line:("+location.x+","+location.y+")--"+"("+endPoint.x+","+endPoint.y+")")
    }
    override def moveTo(newLocation:Point){
            endPoint.shift(newLocation.x - location.x,newLocation.y - location.y) //直线移动时，先移动另外一个端点
        location = newLocation //移动位置
        }
        override def zoom(scale:Double){
        val midPoint = Point((endPoint.x + location.x)/2,(endPoint.y + location.y)/2) //求出中点，并按中点进行缩放
        location.x = midPoint.x + scale * (location.x - midPoint.x)
        location.y = midPoint.y + scale * (location.y -midPoint.y)
        endPoint.x = midPoint.x + scale * (endPoint.x - midPoint.x)
        endPoint.y = midPoint.y + scale * (endPoint.y -midPoint.y)
        }
    }
    class Circle(center:Point,var radius:Double) extends Shape(center) with Drawable{
    override def draw(){//按指定格式重载click
        println(s"Circle center:(${location.x},${location.y}),R=$radius")
    }
        override def zoom(scale:Double){
    radius = radius*scale //对圆的缩放只用修改半径
        }
    }
    

    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
        }
    }
    

　　　　结果截图：

　　　　　　　

　　　　题目3

　　　　

object scoreReport
 {
     def main(args:Array[String])
     {
         //假设数据在当前目录下
         val inputFile=scala.io.Source.fromFile("test.txt")
         
         //"\s"是字符串正则表达式，将每行按空白字符（包括空格/制表符）分开
         //由于可能涉及多次遍历，通toList将Itertor装为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
         
         
         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${result._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)
     
     }
     
 }

　　　　结果截图：