运算符、流程控制

运算符

var a:Int=10/3  //a=3
var b:Double=10/3  //b=3.0
//这里是10/3结果为int类型，然后转换为double类型，所以是3.0而不是3.3333333333333335
var c:Double=10.0/3  //c=3.3333333333333335
var c=10.0/3  //c=3.3333333333333335
1
2
3
4
5

怎样格式化输出c？

println(c.formatted("%.2f")) //3.33
//.2f表示四舍五入保留两位小数
1
2

比较运算符和java一致。
比较运算符

在java中：当字符串s1和s2内容相同但地址不同时，用“==”比较符则为false。有专门的判断字符串内容是否相同的方法。s1.equals(s2)，若s1与s2内容相同则返回true，反之false。

String s1="hi";
String s2=new String("hi");
System.out.println(s1==s2);//false
System.out.println(s1.equals(s2));//true
1
2
3
4

而在Scala中判断的直接是s1与s2的内容是否相同，所以==和equals结果相同。

println(s1==s2)//true
println(s1.equals(s2))//true
1
2

那么在Scala中如何判断字符串地址是否相同？

println(s1.eq(s2))//false
1

逻辑运算符
基本和java一致。
判断一个字符串是否为空

def isNotEmpty(str:String):Boolean={
  return str!=null && !("".equals(str.trim))
}
1
2
3

赋值运算符
基本和java一致。但java中有自增“++”和自减“–”，而Scala没有。

在Java中

byte b=10;
b=b+1; //报错，b+1会自动转型（低精度转高精度）为int类型
//而int类型不能自动转型为byte类型，此处要强转
b=(byte)(b+1);
//或者可以用+=
b+=1; //这里会自动强转
1
2
3
4
5
6

在Scala中

var b:Byte=10
b+=1 //报错，Scala中不能这样做
var i:Int=10
i+=1  //可以
1
2
3
4

流程控制

条件语句
if…else 语法和java一致
不同之处：在Scala中，if和else if语句是有返回值的

object Student{
  def main(args: Array[String]): Unit = {
    var age:Int=StdIn.readInt();//输入3
    //这里返回值类型为Unit，说明无返回值，所以输出为空括号
    val m:Unit=if(age<=5){
      println("w")
    }else{
      println("d")
    }
    println(m);//输出的为一个空括号()
  }
}
1
2
3
4
5
6
7
8
9
10
11
12

若想要m中有内容，需要在if和else if语句后面添加对应的返回值

object Student{
  def main(args: Array[String]): Unit = {
    var age:Int=StdIn.readInt();
    val m:String=if(age<=5){
      println("w")
      "www"
    }else{
      println("d")
      "ddd"
    }
    println(m);
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

如果m的返回值既想要有string又想有int，则设置返回值类型为int和string的公共父类any

object Student{
  def main(args: Array[String]): Unit = {
    var age:Int=StdIn.readInt();
    val m:Any=if(age<=5){
      println("w")
      "www"
    }else{
      println("d")
      age
    }
    println(m);
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

scala中if…else更简洁的写法：

val a=if(age>=18) "成年" else "未成年"
1

For循环

for(i<- 1 to 10){//表示i从1-10
	print(i+" ")
}
1
2
3

如果不想包含后边界，有两种写法

//Range()
for(i<- Range(1,10)){
	print(i+" ")//i从1-9
}
//until
for(i<- 1 until 10){
	print(i+" ")//i从1-9
}
1
2
3
4
5
6
7
8

集合遍历
Scala中集合遍历不需要用索引，很方便

for(i<- Array(12,34,56,99)){
      println(i)
}
for(i<- List(12,34,56,99)){
      println(i)
}
for(i<- Set(12,34,56,99)){
      println(i)
}
1
2
3
4
5
6
7
8
9

循环守卫

//表示当i!=2时才循环
for(i<- 1 to 4 if i!=2){
	print(i+" ")//输出1 3 4 
}
//等同于
for(i<- 1 to 4){
	if(i!=2){
		//循环内容
    }
}
1
2
3
4
5
6
7
8
9
10

循环步长
循环时默认步长为1，相当于java中的 i ++，但可以人为设置，选择跳着取循环变量 i 的值，例如 i 为1-10范围内的偶数
则 i 的取值为 2 4 6 8 10 这里就相当于 i 每次加2

for(i<- 2 to 10 by 2){
	print(i+" ") //2 4 6 8 10
}
1
2
3

当循环变量范围设置为从小到大，但步长设置为负数时，循环不会输出内容，因为表示步数后退

//不进行循环，因为步数为负而i表示1-10
for(i<- 1 to 10 by -2){
}

//可以循环，步数为负，但i表示10-1
for(i<- 10 to 1 by -2){
	print(i+" ")//10 8 6 4 2
}
1
2
3
4
5
6
7
8

想要倒着输出，还可以：

//这里要记得导包，否则报错
import scala.language.postfixOps

for(i<- 1 to 10 reverse){
	print(i+" ")//10 9 8 ...
}
//注意不能写成,循环不会进行
for(i<- 10 to 1 reverse){
}
1
2
3
4
5
6
7
8
9

当然，步长也可以是double类型，不过 i 的类型也要是double类型。但这样可能会导致数据丢失，比如当步长为0.3时，因为不能整除的原因导致部分数据舍去

for(i<- 1.0 to 10.0 by 0.5){
	print(i+" ")
}
1
2
3

嵌套循环

//基础写法 显然是一个10*10矩阵
for(i<- 1 to 10){
	for(j<- 1 to 10){
		print(i+" "+j)
	}
}

//改进写法
for(i<-1 to 10; j<- 1 to 10){
}
1
2
3
4
5
6
7
8
9
10

打印一个九九乘法表

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

//简写
for(i<- 1 to 9;j<- 1 to i){
	print(s"$j*$i=S{i*j} \t")
	if(j==i) println()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

引入变量
写起来有点像前面的双重for循环，但是含义不一样。这里的 j 是直接赋值操作，并非代表另一层循环的循环变量。

应用场景

//每个j都有个i与之对应
for(i<- 1 to 10){
	val j=10-i
	print(i+" "+j)
}

//可以改写为，这样更加简洁
for(i<- 1 to 10;j=10-i){
	print(i+" "+j)
}
//还可以这样写
//用花括号代替圆弧括号，分两行写，可以不用写分号
for{
	i<- 1 to 10
	j=10-i
}
{
	print(i+" "+j)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

输出九层妖塔

for(i<- 1 to 18 by 2;j=(18-i)/2){
	println(" "*j+"*"*i+" "*j)
}
1
2
3

while循环
while和do…while循环用法和java中一样，但不推荐使用while

循环中断

//使用抛出异常终止循环
object Student{
  def main(args: Array[String]): Unit = {
    try{
      for(i<- 0 until 5){
        if(i==3)
          throw new RuntimeException
        println(i)
      }
    }catch {
      case e:Exception=> //什么都不做，只是退出循环
    }
    println("这是循环语句")
  }
}

//简化代码
//使用Scala中Breaks类的break方法，实现异常的抛出和捕捉
//要引入包
import scala.util.control.Breaks._

object Student{
  def main(args: Array[String]): Unit = {
    breakable(
      for (i<- 0 until 5){
        if(i==3)
          break()
        println(i)
      }
    )
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32