Scala中的控制表达式

Scala中的控制表达式包含：if语法，for语法，while语法，异常语法，break语法等

我现在来梳理一下：

if表达式：我们创建一个IfExpression.scala,代码如下：
class IfExpression(){

  var fileName = "default.txt"
  //如果参数不为空的时候，将第一项给fileName
  def check(args: Array[String]): String=
    if(!args.isEmpty) args(0) else fileName

  println("fileName:" + fileName)
}

for语法：创建一个ForExpression.scala代码如下：

//for循环使用
class ForExpression{

  //得到文件列表，并遍历打印文件
  def forFiles(): Unit = {
    val fileHere = (new java.io.File(".")).listFiles
    for(file <- fileHere)
      println("file:" + file)
  }

  def forFileIndex(): Unit = {
    val fileHere = (new java.io.File(".")).listFiles
    for(i <- 1 to fileHere.length - 1)
      println("fileHereIndex:" + fileHere(i) +" " + i)
  }

  //进行过滤filter 不同的形式
  def forFileFilter(): Unit = {
    val fileHere = (new java.io.File(".")).listFiles
    for(file <- fileHere if file.getName.endsWith(".scala"))
      println("forFileFilter:" + file)
  }

  def forFileFilter2(): Unit = {
    val fileHere = (new java.io.File(".")).listFiles
    for(file <- fileHere)
      if(file.getName.endsWith(".scala"))
        println("forFileFilter2:" + file)
  }

  def forFileFilter3(): Unit = {
    val fileHere = (new java.io.File(".")).listFiles
    for(
      file <- fileHere
      if file.isFile
      if file.getName.endsWith(".scala")
    )println("forFileFilter3:" + file)
  }

  //查询文件中的内容
  def fileLines(file: java.io.File) =
    scala.io.Source.fromFile(file,"UTF-8").getLines().toList

  //管道  过滤相关的字符串
  def grep(pattern: String) = {
    //遍历当前目录下面所有的文件
    val filesHere = (new java.io.File(".")).listFiles
    //遍历所有的文件
    for(file <- filesHere){
      //比较文件名是否已.scala结尾
      if(file.getName.endsWith(".scala")){
        //读取相关文件为文件内容
        for(line <- fileLines(file)){
          //将文件的内容去除空格并查询内容里面有pattern的文件
          if(line.trim.matches(pattern)){
            println(file + ": " + line.trim)
          }
        }
      }
    }
  }

  //定义多个变量(stream变量)
  def grep2(pattern: String) = {
     val filesHere = (new java.io.File(".")).listFiles
     for(file <- filesHere){
       if(file.getName.endsWith(".scala")){
         for(line <- fileLines(file)){
           //定义一个变量保存文件的内容
           val trimmed = line.trim
           if(trimmed.matches(pattern)){
             println(file + ": " + trimmed)
           }
         }
       }
     }
  }

  //上面的循环中，都是执行了循环之后，就会清除所有元素，但是有时候我们需要将去记住，供其他使用 我们需要使用yield关键字

}

while语法：使用while循环,创建一个WhileExpression.scala，代码如下：

//进行while语法归类
//while和do-while结构称为循环，而不是表达式，因为它们不会产生有趣的值。
//结果的类型是Unit。事实证明，存在一个类型为Unit的值(实际上只有一个值)。
//它被称为单位值，名为()。()的存在是Scala单元不同于Java void的地方
class WhileExpression{

  //while只要条件为真（这里是先判断）的情况就会执行循环，do-while将先运行循环体中的代码，在判断条件
  def gcdLoop(x: Long,y: Long): Long = {
    val a = x
    val b = y
    while(a != 0){
      val temp = a
      a = b % a
      b = temp
    }
    b
  }

  def doWhileMethod(line: String){
    do{
      line = readLine()
      println("Read:" + line)
    }while(line != "")
  }

}
 

异常:创建一个ExceptionHandlerExpression.scala，代码如下：

import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOException
import java.net.URL
import java.net.MalformedURLException

class ExceptionHandlerExpression{

    //抛出异常  不许输入为偶数
    def half(n: Int): Unit =
      if(n % 2 == 0)
        n / 2
      else
        throw new RuntimeException("n must be even")

    //使用try-catch进行异常的使用
    //与Java不同，Scala不需要捕捉检查过的异常，或者在throw子句中声明它们
    def tryCatchEx(): Unit = {
      try{
        val file = new FileReader("exceptionUse.txt");
        println(file)
      }catch{
        case ex: FileNotFoundException => println("不存在相应的文件")//没有相关文件
        case ex: IOException => println("出现IO异常")//其他的IO异常
      } finally{
        file.close()
      }
    }

    def g(): Int =
      try{
        return 1
      }finally{
        return 2
      }

    def f(): Int =
      try{
        1
      }finally{
        2
      }

    def urlFor(path: String) =
      try{
        new URL(path)
      }catch{
        case ex: MalformedURLException =>
          new URL("https://www.baidu.com")
      }

}
并使用创建一个运行的类：ExceptionHandlerRun.scala

object ExceptionHandlerRun{

  def main(args: Array[String]){
    val exceptionHandlerExpression = new ExceptionHandlerExpression()
    exceptionHandlerExpression.half(4)   //将不抛出异常
    exceptionHandlerExpression.half(3)  //将抛出必须为偶数的异常
    //try-catch进行异常的使用
    exceptionHandlerExpression.tryCatchEx()
  }

}

之后我们将其他相关的放在了主的运行类中：ScalaControlStructures.scala

//scala中的控制语句
import scala.util.control.Breaks._
import java.io._

object ScalaControlStructures{
  val fileName = "default.txt"
  //scala的程序入口
  def main(args: Array[String]){
    //if语句
    val ifExpression = new IfExpression()
    println("main if expression:" + ifExpression.check(args))

    println("这是直接在方法里面进行if语句：" + (if(!args.isEmpty) args(0) else "default.txt"))

    //for循环的使用
    val forExperssion = new ForExpression()
    forExperssion.forFiles()
    //to是包含4的
    for(i <- 1 to 4)
      println("forindex:" + i)

    //until 不包含4
    for(i <- 1 until 4)
      println("foruntilindex:" + i)

    //进行文件遍历
    forExperssion.forFileIndex()
    //进行filter过滤文件
    forExperssion.forFileFilter()
    forExperssion.forFileFilter2()
    forExperssion.forFileFilter3()

    //grep 管道查询相关字符
    forExperssion.grep(".*gcd.*")
    forExperssion.grep2(".*gcd.*")

    //使用match表达式
    val firstArg = if(args.length > 0) args(0) else ""

    firstArg match {
      case "tony" => println("love")
      case "love" => println("scala")
      case "name" => println("huqian")
      case _ => println("huh?")
    }

    val firstArgFriend = if(!args.isEmpty) args(0) else ""

    val friend =
      firstArgFriend match {
        case "love" => "scala"
        case "tony" => "love"
        case "name" => "huqian"
        case _ => "huhs?"
      }
    println("friend:" + friend)

    //scala中没有continue和break关键字
    var i = 0
    var fountIt = false
    while(i < args.length && !fountIt){
      if(!args(i).startsWith("-")){
        if(args(i).endsWith(".scala")){
          fountIt = true
          println("i:" + i)
        }
      }
      i = i + 1
    }

    searchFrom(0,args)

    //如果在特定的场合必须要使用break的话，可以导入scala的Breaks类，这个类在scala.util.control
    //这个类提供了一个break的方法
    // val input = new BufferedReader(new InputStreamReader(System.in))
    // breakable{
    //   while(true)
    //     println("? ")
    //     if(input.readLine() == "")
    //       break
    // }

    //变量的作用域
    printMutilTable()
    muiltTable()
  }

  def searchFrom(idx: Int,args: Array[String]): Unit =
    if(idx >= args.length) println("idx:" + -1)
    else if (args(idx).startsWith("-"))
      searchFrom(idx + 1,args)
    else if (args(idx).endsWith(".scala"))
      println("idx:" + idx)
    else
      searchFrom(idx + 1,args)

  //在同一个作用域中，只能有一个变量名相同  如果在一个作用域中使用了多个相同的变量名，将编译失败
  //在不同的作用域使用同样的变量名称，是可以通过的 取值的时候就近取值
  def printMutilTable(){
    var i = 1  //仅仅在这个作用域有用
    while(i <= 10){
      var j = 1  //i和j在这个作用域有用
      while(j <= 10){
        val prod = (i * j).toString  //i和j和prod在这个作用域有用
        var k = prod.length //i和j和prod和k在这个作用域有用
        while(k < 4){
          print(" ")
          k += 1
        }
        print(prod)
        j += 1
      }
      println()
      i += 1
    }
  }

  //返回一个序列
  def makeRowSeq(row: Int) =
    for(col <- 1 to 10) yield{
      val prod = (row * col).toString
      val padding = " " * (4 - prod.length)
      padding + prod
    }

  def makeRow(row: Int) = makeRowSeq(row).mkString

  def muiltTable() = {
    val tableSeq =
      for(row <- 1 to 10)
      yield makeRow(row)

    tableSeq.mkString("\n")
  }

}

编译运行即可