Scala入门详解（四）

个人博客原文链接

IO

/**
  * IO
  * Scala进行文件写操作，直接用的都是java中的I/O类（java.io.File)
  */
object TestIO {
  def main(args: Array[String]): Unit = {
    // 写操作
//    val writer = new PrintWriter(new File("test.txt" ))
//    writer.write(" 测试成功")
//    writer.close()

    // 从屏幕上读取用户输入
//    print("请输入您的姓名：")
//    val line = StdIn.readLine()
//    println(line+"先生，欢迎您~")

    // 从文件上读取内容
    Source.fromFile("test.txt").foreach{
      print
    }

  }
}

迭代器(Iterator)

/**
  * Iterator（迭代器）
  * Scala Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法。
  * 迭代器it的两个基本操作是 next和hasNext。
  * 调用it.next()会返回迭代器的下一个元素，并且更新迭代器的状态。
  * 调用it.hasNext()用于检测集合中是否还有元素。
  * 让迭代器 it 逐个返回所有元素最简单的方法是使用 while 循环
  */
object TestIterator {
  def main(args: Array[String]): Unit = {
    val it = Iterator("a","b","c")
    // 迭代输出
    while(it.hasNext)
      println(it.next())

    // 最大值，最小值，只能同时获得其中一个，最大值或最小值
    val num = Iterator(3,7,4,2,9)
    println(num.min)
//    println(num.max)

    // 迭代器的长度，两种方式
    val it2 = Iterator(1,1,2)
    println(it2.size)
//    println(it2.length)
  }
}

模式匹配

/**
  * 模式匹配
  * match对应Java里的switch，但是写在选择器表达式之后。即： 选择器 match {备选项}。
  * match 表达式通过以代码编写的先后次序尝试每个模式来完成计算，
  * 只要发现有一个匹配的case，剩下的case不会继续匹配
  */
object TestMatch {
  def matchTest(x: Any): Any = x match {
    case 1 => "one"
    case "two" => 2
    case y: Int => "scala.Int"
    // 表示默认的全匹配备选项,类似switch中的default
    case _ => "many"
  }

  def main(args: Array[String]): Unit = {
    println(matchTest(1))
    // 样例类
    // 一个类被声明为样例类，主构造器的所有参数会被编译成类的属性
    // Scala 会自动给样例类生成伴生对象，以及实现apply和unapply方法等以及其他方法
    case class Person(name: String, age: Int)

    val alice = new Person("Alice", 25)
    val bob = new Person("Bob", 32)
    val charlie = new Person("Charlie", 32)

    for (person <- List(alice, bob, charlie)) {
      person match {
        case Person("Alice", 25) => println("Hi Alice!")
        case Person("Bob", 32) => println("Hi Bob!")
        case Person(name, age) =>
          println("Age: " + age + " year, name: " + name + "?")
      }
    }
  }
}

闭包

/**
  * 闭包
  */
object TestMultiplier {
  def main(args: Array[String]): Unit = {
    // 闭包是一个函数，返回值依赖于声明在函数外部的一个或多个变量
    var a = 3
    val multiplier = (i:Int) => i*a
    println(multiplier(1))
    println(multiplier(2))
    println(multiplier(3))
  }
}

选项(Option)

/**
  * Option
  * Scala Option(选项)类型用来表示一个值是可选的（有值或无值)。
  * Option[T] 是一个类型为 T 的可选值的容器：如果值存在，Option[T] 就是一个Some[T] ，
  * 如果不存在，Option[T] 就是对象None
  */
object TestOption {
  def main(args: Array[String]): Unit = {
    // 声明
    val a:Option[Int] = Some(1)
    val b:Option[Int] = None

    // 如果有值的话，可以通过get方法获取值
    println(a.get)

    // getOrElse()方法
    // 有值就直接获取值，没有值就使用默认值
    println(a.getOrElse(10))
    println(b.getOrElse(10))

    // isEmpty()方法
    // 检测元组中的元素是否为none
    println(a.isEmpty)
    println(b.isEmpty)

  }
}

正则表达式

/**
  * 正则表达式
  */
object TestRegex {
  def main(args: Array[String]): Unit = {
    // 使用String类的r()方法构造了一个Regex对象
    val pattern = "Scala".r
    val str = "Scala is Scalable and cool"
    // 使用 findFirstIn 方法找到首个匹配项
    println(pattern.findFirstIn(str).get)
    // 使用 findAllIn 方法查找所有匹配项，使用逗号连接返回结果
    println(pattern.findAllIn(str).mkString("|"))
    // 使用 replaceFirstIn( ) 方法来替换第一个匹配项
    val pattern2 = "(S|s)cala".r
    println(pattern2.replaceFirstIn(str,"Java"))
    // 使用 replaceAllIn( ) 方法替换所有匹配项
    println(pattern2.replaceAllIn(str,"Java"))

    // 正则表达式
    val pattern3 = new Regex("[a-zA-Z][s]")
    println(pattern3.findFirstIn(str).get)
  }
}