1、异常

try{

var i = 1/0

} catch {

case e: ArithmeticException => e.printStackTrace()

case e: NumberFormatException => e.printStackTrace()

case _:Exception =>println("文件找不到") }

2函数的特性的补充

2.1 默认参数函数

说明：就是函数的参数列表已经复制就是默认参数，在调用函数的时候，此参数就可以不赋值。

object Demo8 {
  def main(args: Array[String]): Unit = {
    showAddress("zs", 15559577595L, "重庆")
    showAddress("ls", 1111111111L, "杭州")
  }

  def showAddress(name:String, phone:Long, province:String, country:String = "中国") = {
    println(s"name = ${name}, phone = ${phone}, province = ${province}, country = ${country}")
  }
}

2.2 带名的参数函数

就是直接在函数列表赋值参数

object Demo8 {
  def main(args: Array[String]): Unit = {
    // 调用函数的时候可以申明函数参数名调用
    showAddress(phone = 1111122222L, province = "苏州", name = "rock")
  }

  def showAddress(name:String, phone:Long, province:String, country:String = "中国") = {
    println(s"name = ${name}, phone = ${phone}, province = ${province}, country = ${country}")
  }
}

2.3 可变参数

package com.qf.bigata.scala

object Demo9 {
  def main(args: Array[String]): Unit = {
    //1. 和java一样
    println(add(1,2,3))
    println(add(1,2,3,4,5))

    //2. 和java不同
    val arr = Array(3,4,5)
    println(add(arr: _*)) // 在scala中不能直接传递数组
  }

  def add(arr: Int*) = {    //这里就是可变参数的表示
    var sum = 0
    for(a <- arr) sum += a
    sum
  }
}

我们可以回顾一下java的可变参数 三个点点！

public void print(String...names) {    
int count = names.length;    // 获取总个数        
System.out.println("本次参加考试的有"+count+"人，名单如下：");        
for(int i = 0;i < names.length;i++) {            
System.out.println(names[i]);      
} 
}

3、集合类型

3.1数组 ArrayBuffer : 理解为java的ArrayList

package com.qf.bigata.scala

import scala.collection.mutable.ArrayBuffer

object Demo11 {
  def main(args: Array[String]): Unit = {
    //1. 定义
    val buffer1 = new ArrayBuffer[Int]()
    val buffer2: ArrayBuffer[String] = ArrayBuffer[String]("lixi", "rock")

    //2. crud
    println(buffer2.length)
    println("增---------------------------->")
    buffer2.append("lee")
    println(buffer2.length)
    buffer2.append("rocklee", "sakura", "narudo")
    println(buffer2.length)
    println(buffer2.mkString(","))
    buffer2.insert(3, "2b")
    println(buffer2.mkString(","))

    println("查---------------------------->")
    println(buffer2(3))
    println(buffer2.size)

    println("改---------------------------->")
    buffer2(3) = "sb"
    println(buffer2.mkString(","))

    println("删---------------------------->")
    buffer2.remove(3) // 删除指定索引位置上的元素
    println(buffer2.mkString(","))
    buffer2.remove(3, 2)
    println(buffer2.mkString(","))

    //drop : 不是删除原数组，将原数组中的元素在内存中做副本删除之后生成新的副本
    println("drop---------------------------->")
    println(buffer2.mkString(","))
    val buffer3: ArrayBuffer[String] = buffer2.drop(2) // 按照左边顺序删除2个元素,生成新的副本
    println(buffer2.mkString(",")) // drop不会对原数组造成破坏
    println(s"buffer3: ${buffer3.mkString(",")}") // drop不会对原数组造成破坏
    val buffer4: ArrayBuffer[String] = buffer2.dropRight(2)
    println(s"buffer4: ${buffer4.mkString(",")}") // drop不会对原数组造成破坏
  }
}

不可变的：Array:理解为java的普通数组

package com.qf.bigata.scala

object Demo10 {
  def main(args: Array[String]): Unit = {
    //1. 定义数组
    //1.1 类似于java中的动态初始化数组
    val array1 = new Array[Int](5) // 自定义一个Int类型数组，并且数组长度是5，每个数组元素默认值为0
    array1.foreach(println)
    println("-" * 10)

    //1.2 类似于java中的静态初始化数组：伴生对象方式创建
    val array2 = Array(1,2,3,4) // 自定义一个Int类型数组，并且数组长度是4，数组元素分别为：1，2，3，4
    array2.foreach(println)
    println("-" * 10)

    //2. 获取到数组的元素:数组名(index)
    println(array2(2)) // java:array2[2]
    println("-" * 10)

    //3. 数组的遍历
    /*
     * //3.1 传统写法
     * for(element <- 数组名) {
     *  element : 数组中的每个元素
     * }
     *
     * //3.2 函数式编程的写法
     * 数组名.foreach(element => {
     *  element : 数组中的每个元素
     * })
     */

    //4. 数组的长度
    println(array2.length)
    println(array2.size)
    println("-" * 10)

    //5. 判断一个数组元素是否在一个数组中
    println(s"判断3是不是在array2的数组中：${array2.contains(-3)}")
    println("-" * 10)

    //6. 数组元素拼接 : mkString
    println(s"数组元素：${array2.mkString}") // 没有分隔符
    println(s"数组元素：${array2.mkString(",")}") // 逗号分隔符
    println(s"数组元素：${array2.mkString("[", ",", "]")}") // 逗号分隔符，前后加上符号

    //7. 所谓的不可变指的什么？
    //7.1 所谓的不可变并不是指值不可变
    //7.2 指的是数组长度不变
    array2(0) = 10
    println(s"数组元素：${array2.mkString("[", ",", "]")}") // 逗号分隔符，前后加上符号
    array2(4) = 11
    println(s"数组元素：${array2.mkString("[", ",", "]")}") // 逗号分隔符，前后加上符号
  }
}

通用操作

package com.qf.bigata.scala

import scala.collection.mutable
import scala.collection.mutable.ArrayBuffer

object Demo12 {
  def main(args: Array[String]): Unit = {
    val buffer: ArrayBuffer[Int] = ArrayBuffer[Int](1,2)
    val arr = Array(3,4,5)

    //contains : 判断一个元素是否在这个数组
    println(s"${buffer.contains(s"lixi")}, ${arr.contains(3)}")

    // 数组求和
    println(s"${arr.sum}, ${buffer.sum}")

    // 最大最小值
    println(s"${arr.max}, ${buffer.max}")
    println(s"${arr.min}, ${buffer.min}")

    // Array和ArrayBuffer相互转换
    val newBuffer: mutable.Buffer[Int] = arr.toBuffer // array -> arrayBuffer
    val newArray: Array[Int] = buffer.toArray // arrayBuffer -> array
  }
}