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