Scala | Scala基础语法二

1、if…else判断语句

知识点：

1. scala的if else 用法及结构同java
2. scala的if else 有返回值的，可以接
3. sacla的返回值，不需要加return关键字
   通用规则：scala会将方法体{}最后的一行代码当作返回值返回
4. println()：打印并换行
   println()：打印不换行
5. scala的Unit，类比于java的void，即空类型
6. scala的打印函数返回值类型为Unit(空类型)
7. scala通用的简化规则：如果方法体{}中只有一行代码，则{}可以省略

object Demo03 {
  println("Welcome to the Scala worksheet")       //> Welcome to the Scala worksheet
  
  val num=9                                       //> num  : Int = 9
  
  val r1=if(num>10){
    println("big")
    1000
  }else{
    println("small")
    500
  }                                               //> small
                                                  //| r1  : Int = 500
  
  
  val num01=4                                     //> num01  : Int = 4
  
  val r2=if(num01>5) println("big") else println("small")
                                                  //> small
                                                  //| r2  : Unit = ()
  
}

2、while和for循环

知识点：

1. scala的while用法及结构同java
2. scala在通过下标操作集合类型时，使用的是(index),不同于java的[index]
3. scala的for循环,结构:for(i<-某个集合数据){处理代码}
4. scala通用的化简规则:如果调用的方法,参数只有一个,则可以把.()省略

object Demo04 {
  println("Welcome to the Scala worksheet")       //> Welcome to the Scala worksheet
  
  val a1=Array(1,2,3,4)                           //> a1  : Array[Int] = Array(1, 2, 3, 4)
  
  var index=0                                     //> index  : Int = 0
  
  while(index<a1.length){
    //操作下标操作数组
    println(a1(index))
    index+=1
  }                                               //> 1
                                                  //| 2
                                                  //| 3
                                                  //| 4
  for(i <- a1){
    println(i)                                    //> 1
                                                  //| 2
                                                  //| 3
                                                  //| 4
  }
  
  //使用scala for，打印出1~10 所有数字
  //to方法用于生成指定的区间集合，一般用于for时的遍历范围
  1.to(10)                                        //> res0: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7
                                                  //| , 8, 9, 10)
  
  for(i <- 1.to(10)){
    println(i)                                    //> 1
                                                  //| 2
                                                  //| 3
                                                  //| 4
                                                  //| 5
                                                  //| 6
                                                  //| 7
                                                  //| 8
                                                  //| 9
                                                  //| 10
  }
  
  1.to(5)                                         //> res1: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5)
  //until也是生成区间集合，含头不含尾
  1.until(5)                                      //> res2: scala.collection.immutable.Range = Range(1, 2, 3, 4)
  
  //生产区集合，并指定步长为2
  1.to(5,2)                                       //> res3: scala.collection.immutable.Range.Inclusive = Range(1, 3, 5)
  1.until(5,3)                                    //> res4: scala.collection.immutable.Range = Range(1, 4)
  
  // 通过scala的for循环打印出如下图形：
  //*
  //**
  //***
  //****
  for(i<-1.to(4)){
  println("*".*(i))                               //> *
                                                  //| **
                                                  //| ***
                                                  //| ****
  }
  
  for(i <- 1 to 9){
    for(j<-1 to i){
      print(i+"*"+j+"="+i*j+"\t")
    }
     println()
  }                                               //> 1*1=1	
                                                  //| 2*1=2	2*2=4	
                                                  //| 3*1=3	3*2=6	3*3=9	
                                                  //| 4*1=4	4*2=8	4*3=12	4*4=16	
                                                  //| 5*1=5	5*2=10	5*3=15	5*4=20	5*5=25	
                                                  //| 6*1=6	6*2=12	6*3=18	6*4=24	6*5=30	6*6=36	
                                                  //| 7*1=7	7*2=14	7*3=21	7*4=28	7*5=35	7*6=42	7*7=49	
                                                  //| 8*1=8	8*2=16	8*3=24	8*4=32	8*5=40	8*6=48	8*7=56	8*8=64	
                                                  //| 9*1=9	9*2=18	9*3=27	9*4=36	9*5=45	9*6=54	9*7=63	9*8=72	9*9=81	
                                                  //| 
  
  for(i<-1 to 10){
    if(i < 6){
    println(i)
    }                                             //> 1
                                                  //| 2
                                                  //| 3
                                                  //| 4
                                                  //| 5
  }
  
  //scala支持将条件语句下载for循环的条件式中
  //这种形式称为for循环的守卫式
  for(i<-1 to 10;if i>6){println(i)}              //> 7
                                                  //| 8
                                                  //| 9
                                                  //| 10
                                                  
  for(i<-1 to 10;if i>6 && i%2==1){println(i)}    //> 7
                                                  //| 9
  
  for(a<- 1 to 9;b<- 1 to a;val sep=if(a==b)"\r\n" else "\t"){
    print(b+"*"+a+"="+b*a+sep)                    //> 1*1=1
                                                  //| 1*2=2	2*2=4
                                                  //| 1*3=3	2*3=6	3*3=9
                                                  //| 1*4=4	2*4=8	3*4=12	4*4=16
                                                  //| 1*5=5	2*5=10	3*5=15	4*5=20	5*5=25
                                                  //| 1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36
                                                  //| 1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49
                                                  //| 1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64
                                                  //| 1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81
  }
 
  val a2=Array(1,2,3,4,5,6)                       //> a2  : Array[Int] = Array(1, 2, 3, 4, 5, 6)
  
  //通过for遍历a2，获取其中的所有的偶数元素，并返回到一个新的集合中
  //for yield表达式：遍历一个集合，返回一个新集合，返回的新集合类型和遍历的集合类型相同
  //比如：遍历操作的是Array，则返回Array，遍历操作的是List，则返回List
  val a3=for(i <- a2 ; if i%2==0 )yield{i}        //> a3  : Array[Int] = Array(2, 4, 6)
 
 
  val l1=List(1,2,3,4)                            //> l1  : List[Int] = List(1, 2, 3, 4)
  
  val l2=for(i<-l1)yield{i}                       //> l2  : List[Int] = List(1, 2, 3, 4)
  
  
  
  val m1=Map("tom"->18,"rose"->25,"jim"->30)      //> m1  : scala.collection.immutable.Map[String,Int] = Map(tom -> 18, rose -> 2
                                                  //| 5, jim -> 30)
  
  for(i<-m1){
   println(i)                                     //> (tom,18)
                                                  //| (rose,25)
                                                  //| (jim,30)
  }
  
  
  for((k,v)<-m1){
   println(k)                                     //> tom
                                                  //| rose
                                                  //| jim
  }
  
  for((k,v)<-m1){
   println(v)                                     //> 18
                                                  //| 25
                                                  //| 30
  }
  
  m1("tom")                                       //> res5: Int = 18
}

3、异常处理机制（try…catch…finally）与match

知识点：

1. scala 的异常处理机制用法结构同java。不同的在于catch中
   需要通过case来对指定的异常进行处理
2. scala 的match,类比于java的switch case
3. scala 的match有返回值,可以接

object Demo05 {
  println("Welcome to the Scala worksheet")       //> Welcome to the Scala worksheet
  
  try{
    throw new RuntimeException
  }catch{
  
  	case t:NullPointerException=>{
  		println("null error")
  	}
  	
  	case t:Exception=>{
  		println("other error")
  	}
  
  }finally{
  	 println("end")
  }                                               //> other error
                                                  //| end
  
  val num=10                                      //> num  : Int = 10
  
  val result=num match{
  	case 10=>{
  		"111"
  	}
  	case 20=>{
  		"222"
  	}
  
  }                                               //> result  : String = 111
}

4、在scala中用什么替代break和continue语句

知识点：

1. scala要实现break效果,需要导包。util.control.Breaks._
2. scala通过import关键字导包
3. scala的导包可以出现在代码的任何地方，但是注意包的作用域范围问题。
   一般都是放到最上面
4. 导包时,_表示导入指定包下的所有类
5. 导包时,可以导入指定包下的指定类。比如 import util.control[a.class,b.class]
6. scala没有continue关键字，需要使用break来实现continue效果
7. 如果breakable在for外,break是跳出循环的作用
   如果breakable在for内,break是continue的作用

import util.control.Breaks._

object Demo06 {
  println("Welcome to the Scala worksheet")       //> Welcome to the Scala worksheet
  
  breakable(
  	for(i<-1 to 5){
  		if(i>3){
  			break
  		}else{
  			println(i)
  		}
  	}
  
  )                                               //> 1
                                                  //| 2
                                                  //| 3
  
  for(i<-1 to 5){
  	breakable(
  	if(i==3){
  		break
  	}else{
  		println(i)
  	}
  	
  	)                                             //> 1
                                                  //| 2
                                                  //| 4
                                                  //| 5
  	
  }
  
}