scala几个简单的案例

package day01.Demo

import scala.io.StdIn

object Demo03 {
  def main(args: Array[String]): Unit = {
    //多重循环,应用案例
    //1.统计三个班的成绩情况,每个班级5个学生,求各个班级的平均成绩以及所有班级的平均成绩学生的成绩从键盘输入
    //2.统计三个班的及格的人数 ,每个班级5个同学
    val classNum = 3
    //班级的个数
    var stuNum = 5
    //班级人数
    var core = 0.0
    //分数
    var classCore = 0.0
    var totalCore = 0.0
    //总成绩
    var passNum = 0 //统计及格的人数

    for (i <- 1 to classNum) {
      //先将core清零
      classCore = 0.0
      for (j <- 1 to stuNum) {
        printf("请输入第%d班级的第%d个学生的成绩\n", i, j)
        core = StdIn.readDouble()

        if (core >= 60) {
          passNum += 1

        }

        classCore += core
      }
      //总成绩
      totalCore += classCore
      printf("第%d个班级的平均分为%.2f\n", i, classCore / stuNum)
    }
    printf("所有班级的平均分为%.2f\n", totalCore / (stuNum * classNum))
    printf("及格人数%d", passNum)


  }

}

//计算矩形的面积
object exercise03 {
  def main(args: Array[String]): Unit = {

    /*
  打印10 * 8的矩形

 */
    val m = new MethodExec
        m.printRect()
    m.len = 3.3
    m.wide = 4.4
    println("面积是:"+m.area())


  }
}

  class MethodExec{
    //计算矩形的面积
    var len = 0.0
    var wide = 0.0

    def printRect(): Unit ={

      for (i<- 0 until  10){
        for (i <- 0 until 8){

          print("*")
        }
        println("*")
      }
    }

    def area() ={

      (this.len * this.wide).formatted("%.2f")
    }

}


//读取指定文件,返回记录行数


import java.io.{BufferedReader, File, FileReader}

import day04.MyImpicits._


class RichFile(file: File) {

  /*
    @return
    返回文件记录行数
   */
  def count(): Int = {

    //读文件,按行读
    val fileReader = new FileReader(file)
    val bufferReader = new BufferedReader(fileReader)
    var sum =0

      try {
        var line = bufferReader.readLine()
        while (line != null) {

          sum += 1
          line = bufferReader.readLine()
        }
      } catch {
        case _: Exception => sum
      } finally {
        fileReader.close()
        bufferReader.close()
      }
    sum
  }
}

object ScalaImplicitFile {
  def main(args: Array[String]): Unit = {
    val file = new File("d:/website.log")
    println("Count = " +file.count())
    println(s"FileComment = ${file.read}")
  }


}


//日常做的练习::::::::::::::::::::::::::::::::::::::::::!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!11




import scala.collection.mutable

object Homework06 {
  def main(args: Array[String]): Unit = {
    //设置一个映射，其中包含你想要的一些装备，以及它们的价格。然后根据这个映射构建另一个新映射，

    val map01 = Map(("张三", 18000), ("大黄", 20000), ("小李子", 20000))
    println(map01)


    //采用同一组键，但是价格上打9折。（提示：可以for遍历集合(k,v) <- map）
    map01.map(x => x._2 * 0.9).foreach(println)


    val map02 = for ((k, v) <- map01) yield (k, v * 0.9)
    println(map02)


    //wordcount,,这种方法不好
    def wordCount(str: String) = {
      val count = new mutable.HashMap[String, Int]()
      for (i <- str.split(" "))
        count(i) = count.getOrElse(i, 0) + 1
      count

    }

    println(wordCount("wo shi hao hao ren, fuck you"))

 //另一种wordcount案例
val line = List("hello scala hello hadoop", "hello hadoop", "hello spark", "hello bigdata")
//切分亚平,通过空格切分
val words = line.flatMap(_.split(" "))
println(words)
//生成元祖
val tuples = words.map((_, 1))
println(tuples)
//以key分组
val grouped = tuples.groupBy(_._1)
println(grouped)
//统计value的长度
val sumed = grouped.mapValues(_.size)
println(sumed)
//排序
val result01 =  sumed.toList.sortBy(_._2)
println(result01)
//降序
val result02 = result01.reverse
println(result02)
  }

    println("~~~~~~~~~~~~~~~")
    //编写一个函数 minmax(values:Array[Int]), 返回数组中最小值和最大值的对偶（提示：数组最大.max，数组最小.min）
    def minmax(values: Array[Int]) = {
      (values.min, values.max)
    }

    val array01 = Array(1, 2, 3, 4, 5)
    println(minmax(array01))


    //编写一个函数，从一个整型列表中去除所有的零值。
    def removezero(ints: List[Int]): List[Int] = {
      ints.filter(x => x != 0)
    }

    val list01 = List(1, 2, 3, 40, 0, 0, 0, 0)
    println(removezero(list01))


    // 编写函数values(fun:(Int)=>Int,low:Int,high:Int),
    // 该函数输出一个集合，对应给定区间内给定函数的输入和输出。
    // 比如，values(x=>x*x,-5,5)应该产出一个对偶的集合(-5,25),(-4,16),(-3,9),…,(5,25)

    def values(fun: (Int) => Int, low: Int, high: Int) = {

      var array02 = List[(Int, Int)]()
      low to high foreach {
        x =>
          array02 = (x, fun(x)) :: array02
      }
      array02
    }

    println(values(x => x * x, -5, 5).reverse)

    //编写一个Time类，加入只读属性hours和minutes，
    // 和一个检查某一时刻是否早于另一时刻的方法before(other:Time):Boolean。
    // Time对象应该以new Time(h,m)方式构建。

    var time = new Time(4, 30)
    println(time.h + ":" + time.m)
    var time1 = new Time(4, 50)
    println(time.before(time1))
    println("~~~~~~~~~~~~")



  }

  class Time(val h: Int, val m: Int) {
    val hours = h
    val minutes = m

    def before(other: Time): Boolean = {
      if (hours < other.hours)
        true
      if (hours == other.hours)
        false
      if (minutes < other.minutes)
        true
      false
    }

  }

}