系列文章目录


提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档


运算符

3.1 算术运算符

±/*%

3.2关系运算符（比较运算符）

Java 和Scala 中关于==的区别

Java：

==比较两个变量本身的值，即两个对象在内存中的首地址； equals 比较字符串中所包含的内容是否相同。

Scala：==更加类似于 Java 中的 equals，参照 jd 工具

    var s1 = "abc"
    var s2 = new String("abc")
    println(s1==s2)//true
    println(s1.eq(s2))//false

3.3 逻辑运算符

&& || !

3.4 赋值运算符

注意：Scala 中没有++、–操作符，可以通过+=、-=来实现同样的效果；

3.5 位运算符

& 与

| 或

！ 非

^ 取反

<< 左移 >> 右移 >>>无符号右移动

3.6 Scala 运算符本质


在 Scala 中其实是没有运算符的，所有运算符都是方法。


• 当调用对象的方法时，点.可以省略
• 如果函数参数只有一个，或者没有参数，()可以省略

    // 标准的加法运算
    val i:Int = 1.+(1)
//    （1）当调用对象的方法时，.可以省略
    val j:Int = 1 + (1)
//    (2)如果函数参数只有一个，或者没有参数，()可以省略
    var k:Int = 1 + 1
    println(1.toString())
    println(1 toString())
    println(1 toString)

第 4 章 流程控制

4.1 if – else

• Scala 中
  
if else 表达式其实是有返回值的

  ，具体返回值取决于满足条件的代码体的最后一行内容。

    var age = StdIn.readInt()
    var res:String = if(age<18){
      "童年"
    }else if(age>=18&&age<30){
      "中年"
    }else{
      "老年"
    }
    println(res)

• Scala 中返回值类型不一致，取它们共同的祖先类型。

    var age = StdIn.readInt()
    var res:Any = if(age<18){
      "童年"
    }else if(age>=18&&age<30){
      "中年"
    }else{
     100
    }
    println(res)

• Java 中的三元运算符可以用 if else 实现


如果大括号{}内的逻辑代码只有一行，大括号可以省略。如果省略大括号，if 只对最近的一行逻辑代码起作用


    var age = StdIn.readInt()
    var res:Any = if(age<18) "童年"
                  else "成年"
    var res1:Any = if(age<18) "童年"  else "成年"
    println(res)
    println(res1)
    res  res1效果一样

4.2Switch 分支结构

在 Scala 中没有 Switch，而是使用模式匹配来处理。

4.3For 循环控制

Scala 也为 for 循环这一常见的控制结构提供了非常多的特性，这些 for 循环的特性被称为 for 推导式或 for 表达式。

4.3.1 范围数据循环（To）


i 前后闭合


 for(i <- 1 to 5) print(i+" ")
 输出 1 2 3 4 5

4.3.2 范围数据循环（Until）


i 前闭后开


for(i <- 1 until  5) print(i+" ")
输出 1 2 3 4

4.3.3 循环守卫

循环守卫，即循环保护式（也称条件判断式，守卫）。保护式为 true 则进入循环体内部，为false 则跳过，类似于continue。

   for(i <- 1 to 3 if i != 2){
     print(i+" ")
   }
   //两者等价  都是输出1 3
    for(i <- 1 to 3 ){
      if( i != 2){
        print(i + " ")
      }
    }

4.3.4 循环步长

by 表示步长

   for(i <- 1 to 10 by 2){
     print(i+" ")
   }
   //输出1 3 5 7 9

4.3.5 嵌套循环

没有关键字，所以范围后一定要加；来隔断逻辑

   for(i <- 1 to 3 ; j <- 1 to 3){
     println("i= "+i+" j= "+j)
   }
   //两者等价
    for(i <- 1 to 3) {
      for( j <- 1 to 3) {
        println("i= "+i+" j= "+j)
      }
    }

4.3.6 引入变量

基本语法

   for(i <- 1 to 3 ; j = 4 - i){
     println("i= "+i+" j= "+j)
   }

（1） for 推导式一行中有多个表达式时，所以要加 ; 来隔断逻辑

（2） for 推导式有一个不成文的约定：当 for 推导式仅包含单一表达式时使用圆括号，

当包含多个表达式时，一般每行一个表达式，并用花括号代替圆括号，如下

    for{
      i <- 1 to 3
      j = 4 - i
    } {
      println("i= "+i+" j= "+j)
    }

上面的代码等价于

    for(i <- 1 to 3) {
      var j = 4 - i
      println("i= "+i+" j= "+j)
    }

4.3.7 循环返回值

  val res = for(i <- 1 to 10) yield i
    print(res)

说明：将遍历过程中处理的结果返回到一个新 Vector 集合中，使用 yield 关键字。注意：开发中很少使用。

2） 案例实操

需求：将原数据中所有值乘以 2，并把数据返回到一个新的集合中。

   var res = for(i <- 1 to 10) yield {
     i*2
   }
  println(res)
  输出Vector(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)

4.3.8 倒序打印

1） 说明：如果想倒序打印一组数据，可以用 reverse。

需求：倒序打印 10 到 1

  for(i <- 10 to 1){//说明：这个不可以
    println(i)
  }
  //这个 reverse可行 
  for(i <- 1 to 10 reverse) {
    println( i)
  }

4.5 While 和 do…While 循环控制

While 和 do…While 的使用和 Java 语言中用法相同。

4.5.1 While 循环控制

1） 基本语法

循环变量初始化
    while (循环条件) {
    循环体(语句) 
    循环变量迭代
}

说明：

（1） 循环条件是返回一个布尔值的表达式

（2） while 循环是先判断再执行语句

（3） 与 for 语句不同，

while 语句没有返回值，即整个 while 语句的结果是Unit 类型()


（4） 因为 while 中没有返回值，所以当要用该语句来计算并返回结果时，就不可避免的使用变量，而变量需要声明在 while 循环的外部，那么就等同于循环的内部对外部的变量造成了影响，所以不推荐使用，而是

推荐使用 for 循环。


  var i = 0
  while (i<10) {
    println(i)
    i = i+1
  }
  输出0-9

4.5.2 do…while 循环控制

  var i = 0
  do{
    println(i)
    i+=1
  }while(i<10)
  输出0-9

4.6 循环中断

1） 基本说明

Scala 内置控制结构特地

去掉了 break 和 continue

，是为了

更好的适应函数式编程

，推荐使用函数式的风格解决break 和continue 的功能，而不是一个关键字。Scala 中

使用breakable 控制结构

来实现 break 和 continue 功能。

需求 1：采用异常的方式退出循环

在这里插入代码片    try {
      for( elem <- 1 to 10 ) {
        println(elem)
        if(elem == 5) throw  new RuntimeException
      }

  }catch {
      case e =>
    }
    println("循环正常结束")
    输出结果1-5 循环正常结束

需求 2：采用 Scala 自带的函数，退出循环

import scala.util.control.Breaks
  Breaks.breakable(
    for(elen <- 1 to 10){
      println(elen)
      if(elen==3) Breaks.break()
    }
  )
    println("循环正常结束")
    1 2 3 循环正常结束

需求 3：对break 进行省略

import scala.util.control.Breaks._
object TestOperate {
  def main(args: Array[String]): Unit = {
  breakable {
    for( elem <- 1 to 10 ){
      println(elem)
      if(elem == 5) break
    }
  }
    println("循环正常结束")
  }
}
1-5循环正常结束

需求 4：循环遍历 10 以内的所有数据，奇数打印，偶数跳过（continue）

import scala.util.control.Breaks._
object TestOperate {
  def main(args: Array[String]): Unit = {
    breakable{
      for( i <- 1 to 10) {
        if(i %2 == 0 ){
          println("continue")
        }else{
          println(i)
        }
      }
    }
  }
}

4.7 多重循环

（1） 将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for，while，do…while均可以作为外层循环和内层循环。【建议一般使用两层，最多不要超过 3 层】

需求：打印出九九乘法表

object TestOperate {
  def main(args: Array[String]): Unit = {
    for(i <- 1 to 9 ){
      var j = 1
      while(j<=i){
        print(""+j+"*"+i+"="+j*i+"\t")
        j = j+1
      }
      println()
    }
  }
}