Spark記錄-Scala語句（運算符-if-for-while-try-模式匹配）

Scala條件運算符

Scala條件運算符在下表中列出。

運算符	操作	描述
&&	與	運算符左側和右側的值為true。 僅當左側為真時，右側才被計算。
||	或	左側或右側的至少一個值為true。僅當左邊為假時才計算右側。
>	大於	左側的值大於右側的值。
>=	大於或等於	左側的值大於或等於右側的值。
<	少於	左側的值小於右側的值。
<=	小於或等於左側的值小於或等於右側的值。
==	等於	左側的值與右側的值相同。
!=	不等於	左側的值與右側的值不同。

注意

&&和||是“短路"運算符。 一旦知道答案，他們就停止計算表達式。

在Java中，==僅比較對象引用。它不會執行邏輯等同性檢查，即比較字段值。使用equals方法。

Scala使用==作為邏輯等式，但它調用equals方法。

當您想要比較引用，但不測試邏輯時，可以使用新的方法eq。

Scala if

Scala中的if表達式的結果始終為Unit。

if/else的結果基於表達式的每個部分的類型。

例子

以下代碼說明了Scala中的表達式。

if (exp) println("yes")

如果exp是true，上面的代碼打印“是”。

像Java一樣，if表達式可能有一個多行代碼塊。

if (exp) {
    println("Line one")
    println("Line two")
}

Scala中的if/else在Java中的行為類似於三元運算符：

val i: Int = if (exp) 1 else 3

並且表達式的任一（或兩者）部分可以具有如下面代碼中所示的多行代碼塊。

val i: Int = if (exp)
                1
             else {
                val j = System.currentTimeMillis
                (j % 100L).toInt
             }

Scala for循環

A For Comprehension是一個非常強大的Scala語言的控制結構。

它提供了迭代集合的能力，它還提供過濾選項和生成新集合的能力。

讓我們從表達式的基本開始：

object Main {
  def main(args: Array[String]) {
     val dogBreeds = List("A", "B", "C", "D", "E", "F") 

     for (breed <- dogBreeds) 
       println(breed) 
  }
}

Expression的Basic是for表達式的一個非常基本的特性。

首先，我們需要一個用於表達式將迭代的集合。我們創建一個書籍列表，如下面的代碼所示：

val books = List("Scala", "Groovy", "Java", "SQL", "CSS")

現在我們可以寫一個非常基本的表達式來遍歷圖書列表。

object Main {
  def main(args: Array[String]) {
    val books = List("Scala", "Groovy", "Java", "SQL", "CSS")
    for (book<-books)
       println(book)
  }
}

在上面的代碼中for表達式為列表書中的每個元素創建一個名為book的臨時變量以及該元素的相應值。

左箭頭操作符稱為生成器，因為它從表達式中使用的集合生成相應的值。

生成器表達式

表達式 breed <- dogBreeds稱為生成器表達式，因此命名是因為它從集合中生成單個值。

左箭頭運算符（< - ）用於遍歷一個集合，例如List。

我們還可以使用它與范圍來寫一個更傳統的尋找循環：

object Main {
  def main(args: Array[String]) {
     for (i <- 1 to 10) println(i) 
  }
}

約束: 過濾值

我們可以添加if表達式來過濾我們想要保留的元素。

這些表達式稱為約束。

要找到我們的狗品種列表中的所有D，我們修改前面的例子如下：

object Main {
  def main(args: Array[String]) {
     val dogBreeds = List("D", "Y", "D", "S", "G", "P") 
     for (breed <- dogBreeds 
       if breed.contains("D") 
     ) println(breed) 
  }
}

您可以有多個約束：

object Main {
  def main(args: Array[String]) {
     val dogBreeds = List("D", "Y", "D", "S", "G", "P") 

     for (breed <- dogBreeds 
       if breed.contains("D") 
       if  !breed.startsWith("Y") 
     ) println(breed) 

     for (breed <- dogBreeds 
       if breed.contains("D") &&  !breed.startsWith("Y") 
     ) println(breed) 

  }
}

過濾器是for表達式中的if子句，用於過濾集合，當我們不想遍歷整個集合時。

以下代碼顯示如何在我們的書籍列表中查找所有Scala圖書。

object Main {
  def main(args: Array[String]) {
    val books = List("Scala", "Groovy", "Java", "SQL", "CSS")
    for(book<-books
        if book.contains("Scala")
    ) println(book)
  }
}

可變綁定

我們可以為表達式定義變量。

然后我們可以在你的for表達式的正文中重用這些變量。

object Main {
  def main(args: Array[String]) {
    val books = List("Scala", "Groovy", "Java", "SQL", "CSS")
    for {
        book <- books
        bookVal = book.toUpperCase()
    } println(bookVal)
  }
}

bookVal沒有聲明為val，但是你仍然可以重用它。

Yielding

在Scala的for表達式中，我們可以使用yield關鍵字來生成新的集合。

從for表達式生成的集合的類型從迭代的集合的類型推斷。

要在for循環中將值賦給我們的程序的另一部分，請使用yield關鍵字為表達式生成新的集合。

object Main {
  def main(args: Array[String]) {
     val dogBreeds = List("D", "Y", "D", "S", "G", "P") 
     val filteredBreeds = for { 
       breed <- dogBreeds 
       if breed.contains("T") &&  !breed.startsWith("Y") 
     } yield breed 
  }
}

以下代碼顯示如何對集合使用yield。

object Main {
  def main(args: Array[String]) {
    val books = List("Scala", "Groovy", "Java", "SQL", "CSS")
    var scalabooks = for{
        book <-books
        if book.contains("Scala")
    }yield book

    println(scalabooks);
  }
}

過濾的結果作為名為 book的值生成。

這個結果是在for循環中每次運行時累積的，因此累積的集合被分配給值scalabooks。

scalabook是List [String]類型，因為它是圖書列表的一個子集，也是List [String]類型。

擴展范圍和值定義

用於解釋的Scala可以在 for表達式的第一部分中定義可用於后面表達式的值，如下例所示：

object Main {
  def main(args: Array[String]) {
     val dogBreeds = List("D", "Y", "D", "S", "G", "P") 
     for { 
       breed <- dogBreeds 
       upcasedBreed = breed.toUpperCase() 
     } println(upcasedBreed) 
  }
}

Scala while循環

while循環執行一個代碼塊，只要條件為真。

以下代碼每天打印一次投訴，直到13日的下個星期五到達：

object Main {
  def main(args: Array[String]) {
     import java.util.Calendar 

     def isFridayThirteen(cal: Calendar): Boolean = { 
       val dayOfWeek = cal.get(Calendar.DAY_OF_WEEK) 
       val dayOfMonth = cal.get(Calendar.DAY_OF_MONTH) 
       (dayOfWeek == Calendar.FRIDAY) && (dayOfMonth == 13) 
     } 
     while (!isFridayThirteen(Calendar.getInstance())) { 
       println("Today isn"t Friday the 13th. Lame.") Thread.sleep(86400000) } } }

Scala do-while循環

do-while循環在條件表達式為真時執行一些代碼。

也就是說，do-while檢查在運行塊之后條件是否為真。

要計數到10，我們可以這樣寫：

object Main {
  def main(args: Array[String]) {
     var count = 0 

     do { count += 1 println(count) } while (count < 10) } }

Scala try表達式

Scala中的異常處理以不同的方式實現，但它的行為與Java完全相同，並與現有的Java庫無縫協作。

Scala中的所有異常都未選中；沒有檢查異常的概念。

拋出異常在Scala和Java中是一樣的。

throw new Exception("some exception...")

try/finally結構在Scala和Java中也是一樣的，如下面的代碼所示。

try {
    throw newException("some exception...")
} finally{
    println("This will always be printed")
}

try/catch在Scala是一個表達式，導致一個值。

Scala中的異常可以在catch塊中進行模式匹配，而不是為每個不同的異常提供單獨的catch子句。

因為Scala中的try/catch是一個表達式，所以可以在try / catch中包裝調用，並在調用失敗時分配默認值。

以下代碼顯示了具有模式匹配catch塊的基本try/catch表達式。

try {
    file.write(stuff)
} catch{
    case e:java.io.IOException => // handle IO Exception
    case n:NullPointerException => // handle null pointer
}

例子

以下代碼顯示了通過調用Integer.parseIntand在try/catch中包裝調用的示例，如果調用失敗，則分配默認值。

try{
   Integer.parseInt("dog")
}catch{
   case_ => 0
}

Scala模式匹配

模式匹配允許我們在多個條件之間進行編程選擇。

例子

object Main extends App {
    def printNum(int: Int) {
     int match {
         case 0 => println("Zero") case 1 => println("One") case _ => println("more than one") } } printNum(0) printNum(1) printNum(2) } 

帶下划線_的最后一種情況是通配符。它匹配任何未定義在上面的情況下。

以下代碼說明計算Fibonacci數字的示例。

def fibonacci(in: Int): Int = in match {
 case 0 => 0
 case 1 => 1
 case n => fibonacci(n - 1) + fibonacci(n - 2)
}

Scala允許將守衛放置在模式中，以測試無法在模式聲明本身中測試的特定條件。

因此，如果傳遞負數，我們可以寫入我們的Fibonacci 計算器返回0，如以下示例所示。

def fib2(in: Int): Int = in match {
 case n if n <= 0 => 0
 case 1 => 1
 case n => fib2(n - 1) + fib2(n - 2)
}

匹配任何類型

讓我們考慮一個任何類型的元素的列表，包含一個String，一個Double，一個Int和一個Char。

object Main extends App {
    val anyList= List(1, "A", 2, 2.5, 'a') for (m <- anyList) { m match { case i: Int => println("Integer: " + i) case s: String => println("String: " + s) case f: Double => println("Double: " + f) case other => println("other: " + other) } } } 

測試數據類型

下面的方法測試一個傳入的Object，看看它是一個String，一個Integer，或者別的東西。

def test2(in: Any) = in match {
    case s: String => "String, length "+s.length
    case i: Int if i > 0 => "Natural Int"
    case i: Int => "Another Int"
    case a: AnyRef => a.getClass.getName
    case _ => "null"
}

Scala匹配表達式

Scala的匹配表達式用於模式匹配。

我們可以使用它在很少的代碼中構造復雜的測試。

模式匹配就像Java的switch語句，但我們可以測試幾乎任何東西，我們可以將匹配的值分配給變量。

Scala模式匹配是一個表達式，因此它產生可以分配或返回的值。

最基本的模式匹配就像Java的switch，除了在每種情況下沒有中斷，因為這些情況不會相互影響。

例子

以下代碼將該數字與常量相匹配，但使用默認值。

44 match {
    case 44 => true// if we match 44,the result is true
    case _ => false// otherwise the result isfalse
}

以下代碼顯示如何匹配字符串。

"CSS" match {
    case "CSS"=> 45 // the result is 45 if we match "CSS"
    case "Elwood" => 77
    case _ => 0
}
附錄

object sentence {
def main(args:Array[String]): Unit ={
  //if語句
  val exp=false
  val i: Int = if (exp) 1 else 3
  val j: Int = if (exp) 1
  else {
    val j = System.currentTimeMillis
    (j % 100L).toInt
  }
  println(i+"-"+j)
  //for循環遍歷List
  val books = List("Scala", "Groovy", "Java", "SQL", "CSS")
  for (book<-books)
    println(book)
  for (i <- 1 to 10) println(i)  //生成器表達式左箭頭運算符（< - ）用於遍歷一個集合，例如List。
  //if和for使用
  val dogBreeds = List("D", "Y", "D", "S", "G", "P")
  for (breed <- dogBreeds
       if breed.contains("D")
       if  !breed.startsWith("Y")
  ) println(breed)
  for (breed <- dogBreeds
       if breed.contains("D") &&  !breed.startsWith("Y")
  ) println(breed)
  val bookss = List("Scala", "Groovy", "Java", "SQL", "CSS")
  for(book<-bookss
      if book.contains("Scala")
  ) println(book)
  for {
    book <- books
    bookVal = book.toUpperCase() //轉換為大寫
  } println(bookVal)
  //yield生成新的集合
  var scalabooks = for{
    book <-books
    if book.contains("Scala")
  }yield book
  println(scalabooks);
  //while循環
  import java.util.Calendar
  def isFridayThirteen(cal: Calendar): Boolean = {
    val dayOfWeek = cal.get(Calendar.DAY_OF_WEEK)
    val dayOfMonth = cal.get(Calendar.DAY_OF_MONTH)
    (dayOfWeek == Calendar.FRIDAY) && (dayOfMonth == 13)
  }
  //while (!isFridayThirteen(Calendar.getInstance())) {
   // println("Today isn't Friday the 13th. Lame.")
    //Thread.sleep(86400000)
  //}
  //do-while循環
  var count = 0
  do {
    count += 1
    println(count)
  } while (count < 10)
  //try-catch-finally表達式
  try {
    println(1)
  }
  catch{
    case e:java.io.IOException => // handle IO Exception
    case n:NullPointerException => // handle null pointer
  }
  finally{
    println("This will always be printed")
  }
  //模式匹配
  def printNum(int: Int) {
    int match {
      case 0 => println("Zero")
      case 1 => println("One")
      case _ => println("more than one")
    }
  }
  printNum(0)
  printNum(1)
  printNum(2)
  def fib2(in: Int): Int = in match {
    case n if n <= 0 => 0
    case 1 => 1
    case n => fib2(n - 1) + fib2(n - 2)
  }
  println(fib2(2))
  //匹配任何類型
  val anyList= List(1, "A", 2, 2.5, 'a')
  for (m <- anyList) {
    m match {
      case i: Int => println("Integer: " + i)
      case s: String => println("String: " + s)
      case f: Double => println("Double: " + f)
      case other => println("other: " + other)
    }
    44 match {
      case 44 => true// if we match 44,the result is true
      case _ => false// otherwise the result isfalse
    }
    "CSS" match {
      case "CSS"=> 45 // the result is 45 if we match "CSS"
      case "Elwood" => 77
      case _ => 0
    }
  }
}
}