Scala-day03-运算符和循环控制

一：算术运算符

        1：基本语法

       对于除号，它的整数除和小数除是有区别的，整数之间做除法，只保留整数部分，而舍弃小数部分。

        对于一个数取模a%b，和Java一模一样。

        2：案例

package chapter03

object TestArithmetic {
  def main(args: Array[String]): Unit = {
    var r1:Int = 10/3 //3
    println("r1=" + r1)

    var r2:Double = 10 / 3  //3.0
    println("r2=" + r2)

    var r3:Double = 10.0  / 3 //3.3.333
    println("r3=" + r3)
    println("r3=" + r3.formatted("%.2f")) //保留小数点2位，使用四舍五入

    var r4 = 10 % 3 //1
    println("r4=" + r4)
  }
}

二：关系运算符

        1：基本语法

        2.1：案例1

package chapter03

object TestRelation {
  def main(args: Array[String]): Unit = {

    var a:Int = 2
    var b:Int = 1

    println(a > b)  //true
    println(a >= b)   //true
    println(a <= b)   //false
    println(a < b)    //false
    println("a==b" + (a == b))  //false
    println(a != b)   //true
  }
}

        2.2：案例2

        java中：==比较两个变量本身的值，即两个对象在内存中地址

                        equals比较字符串中所包含的内容是否相同

public static void main(String[] args) {
    String s1 = "abc";
    String s2 = new String("abc");
    System.out.println(s1 == s2);
    System.out.println(s1.equals(s2));
}
输出 结果：
false
true

        Scala：==更加类似于Java中的equals

def main(args: Array[String]): Unit = {
    val s1 = "abc"
    val s2 = new String("abc")
    println(s1 == s2)
    println(s1.eq(s2))
}
输出 结果：
true
false

三：逻辑运算符

        1：基本语法，假设A为true，B为false

        2：案例

package chapter03

object TestLogic {
  def main(args: Array[String]): Unit = {
    var a = true
    var b = false

    println("a&&b=" + (a&&b))   //false
    println("a||b=" + (a || b))   //true
    println("!(a&&b)" + (!(a && b)))  //false
  }
}

四：赋值运算符

        1：基本语法：Scala中没有++、--操作符，可以通过+=、-=来实现同样的效果

         

        2：案例

object TestAssignment {
    def main(args: Array[String]): Unit = {
        var r1 = 10
        r1 += 1 // 没有
        r1 -= 2 // 没有
    }
}

五：位运算符

        1：基本语法：a：60，b：13

         2：案例

object TestPosition {
    def main(args: Array[String]): Unit = {
        // 测试： 1000 << 1 =>10000
        var n1 :Int =8
        n1 = n1 << 1
        println(n1)
    }
}

六：条件分支

        1：单分支

if (条件表达式) {

        执行代码块

}

        2：双分支

if （条件表达式） {

        执行代码块1

} else {

        执行代码块2

}

        3：多分支

if （条件表达式1） {

        执行代码块1

} else if (执行表达式2) {

        执行代码块2

}...

else {

        执行代码块n

}

         4：嵌套分支

if （） {

        if （）{

        }else{

        }

}

七：FOR循环

         1：范围数据循环（To）

for (i <- 1 to 3){
    print(i + " ")
}
println()

//1.i表示循环的变量，<- 规定to
//2.i将会从1-3循环，前后闭合

        2：范围数据循环（Unitl）

for （i <- 1 until 3） {
    print(i + " ")
}
println()

//1.这种方式和前面的区别在于i是从1到3-1
//2.前闭后开的返回

        3：循环守卫

for (i <- 1 to 3 if i != 2) {
    print(i + " ")
}

println()

//1.循环守卫。保护式为true则进入循环体内部，当false则跳过，类似于continue
//2.下面代码等价

for (i <- 1 to 3){
    if (i != 2){
        print(i + " ")
    }
}

        4：循环步长

for (i <- 1 to 10 by 2) {
    print("i=" + i)
}

//输出的结果为1，3，5，7，9

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

//两者等价

        6：引入变量

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

//两者相等

        7：循环返回值

var res = for (i <- 1 to 10) yield {
    i * 2
}
println(res)

//将遍历结果中处理的结果返回到一个新vector集合中，使用yield关键字
//结果 vector（2，4，6，8，10，12，14，16，18，20）

        8：倒序打印

for (i <- 1 to 10 reverse) {
    println(i)
}

//倒序打印10到1

八：while和do..while循环控制

        1：与Java用法相同

        2：while循环控制

object TestWhile {
    def main(args: Array[String]): Unit = {
        var i = 0
        while (i < 10) {
            println("i = " + i)
            i += 1
        }
    }
}

        3：do..while控制

object TestWhile {
    def main(args: Array[String]): Unit = {
        var i = 0
        do {
            println("i =" + i)
            i += 1
        } while (i < 10）
    }
}

九：循环中断

        1：异常方式退出循环

def main(args: Array[String]): Unit = {
    try {
        for (elem < 1 to 10) {
            println(elem)
            if (elem == 5) throw new RuntimeException
        }
    }catch {
        case e =>
    }

    println("正常结束循环")
}

        2：Scala自带函数，退出循环

import scala.util.control.Breaks

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

        3：对break进行省略

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