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