【scala】 scala 条件控制 和异常处理(二)

1.scala 变量定义 ,var val 区别。

var 定义可变变量

val 定义不可变变量，scala 推荐使用。相当于Java的final 变量.

scala中包含的基本数据类型详情如下表所示：

2.scala 条件控制 if else if  else

3. for 增强和 yield类型推导

to  ,until 遍历集合的区别

4.scala 异常处理

try catch {case ex: Exception=> e}finally{}

5. 可变参数方法定义

参数类型*  *定义多个参数

6. def 方法定义的注意

def  方法名(参数)：返回值={方法体}

返回值省略，默认 Any ，Any相当于java中的Object

object Control {

  def main(args:Array[String]): Unit ={
    val a=5
    // scala 尽量不用return,最后一个表达式的值 作为值返回
    val b = if(a<7){val c=a+1;c+3} else if (a==5) 5 else 3
    println(b)
    //数组初始化
    val c:Array[String]=Array("a","b","d")
    //变量定义, 变量名:变量类型
    val d:String = forAry(c)
    println(d)
    //求和
    val result= sum(23,32,32,32,32)
    println(" sum result :"+result)
    // 将整个区间作为参数序列来处理 :_*
    val newResult = sum(1 to 10:_*)
    println("sum newResult: "+newResult)
    //数组格式化输出 toBuffer
    println(yieldAry().toBuffer)
    println("--------------------")
    filter()
    //异常
    exception()
  }

  /**
    * 遍历数组
    * @param ary
    * @return
    */
  def forAry(ary:Array[String]):String={
       val newBuilder=new StringBuilder
      // to 是 i到 区间，包含开始和结尾
       for(i<-10 to ary.length-1){
         newBuilder.append(ary.apply(i))
       }
    // unit 是 0 到 length-1 之间
     for(i<-0 until ary.length){
      newBuilder.append(ary.apply(i))
    }

    //普通遍历
    for(a<-ary) println( a)
     newBuilder.toString()
  }

  /**
    * yield 关键字 推导生成新的数组
    * @return  Array[Int]
    */
  def yieldAry():Array[Int]={
     val ary :Array[Int]= Array(1,32,3,31,43)
       //until  从 0 到 ary.length-1 之间的下标
     for(i<-0 until ary.length){
        val d:Int=ary.apply(i)
        val e= d.*(122);
       // println(e)
     }
     //yield 类型推导为Array
     for(arg<-ary) yield arg *2

  }

  /**
    * 可变长参数定义 *
    * @param args
    * @return
    */
  def sum(args:Int*):Long={
    var result : Long=0
    //for 循环遍历
    for(arg<-args){
      result += arg
    }
    return result
  }

  /**
    * 数组过滤
     */
  def filter(): Unit ={
    //定義一個數組
    val ary =Array(12,2,12,43,2,12,1)
      //去重 过滤
    //保留符合条件的元素 _.%(2)==0 保留偶数,
    // map(_*2) 是各个元素乘以 2
    val a = ary.distinct.filter(_.%(2)==0).map(_*2)
    println(a.toBuffer)
    println(a.sum)//元素求和
  }

  /**
    * 异常处理
    */
  def exception():Unit={
    //定义一个定长的数组
    val ary = new Array[String](2)
    ary(0)="1234e"
    var it = -2
    try{
       it = ary(0).toInt
    }
   catch {
     case ex: FileNotFoundException => it = 0
     case ex: NumberFormatException => it = 12
     case ex:Exception => it = -3
   }finally {
      println(it)
    }
  }

}